Enforce Msg 111 (CREATE/ALTER PROCEDURE/FUNCTION/VIEW/TRIGGER/SCHEMA must be the first statement in a batch). New BatchContext.BlockDepth + HasDispatchedStatement track scope; per-parser check at entry raises with probed wording (PROCEDURE merges CREATE/ALTER; VIEW/FUNCTION/TRIGGER/SCHEMA use separate labels; ALTER TRIGGER differs from CREATE TRIGGER). Inside IF/WHILE/BEGIN-END bodies, BlockDepth > 0 triggers Msg 111 (real SQL Server raises Msg 156 at that position; same end state). Inner BatchContexts (proc/function/trigger/dynamic-SQL bodies) reset the flag, so CREATE PROCEDURE as the first statement of a proc body works. Replaces a silent bug where the first proc's body greedily captured subsequent CREATE PROCEDURE statements as text. New simulation.ExecuteBatches(params) test helper for splitting setup; ~22 existing tests updated to use separate batches for must-be-first statements; 13 new BatchBoundaryTests pin the wording per kind. CLAUDE.md notes the IF/WHILE-body Msg 111-vs-156 divergence.

Author: RyanLamansky

CLAUDE.md

@@ -194,3 +194,4 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **`IF (1) select` paren-wrapped non-boolean cond — slight positional gap**: simulator raises Msg 4145 near `')'`; real SQL Server reports `'select'` (the post-paren token). Wording is correct (Msg 4145, non-boolean type), only the "near 'X'" suffix differs. Same gap applies to any `IF (value-expr) …` shape.
 - **`REPLICATE` of a column-typed `varchar(MAX)` / `nvarchar(MAX)` truncates to 8000 bytes**: the simulator's runtime `SqlValue` doesn't carry the varchar / nvarchar declared length — both bounded `varchar(N)` and `varchar(MAX)` collapse to the length-agnostic singleton at the value level. `Replicate` captures the MAX-vs-bounded distinction at parse time via `Expression.GetSqlType`, which works for literal-only or CAST-target inputs (the common shape) but falls back to "treat as bounded" for column references because the parse-time outer-type resolver doesn't reach FROM-source column types. Threading the projection-time resolver through would lift this; EF's REPLICATE emissions don't hit the affected path.
 - **`DATALENGTH` returns `int` for MAX-typed inputs**: real SQL Server returns `bigint` for `varchar(MAX)` / `nvarchar(MAX)` and the legacy LOB family. Pre-existing simulator divergence; the result still fits in int for any value the simulator can produce, but the declared column type doesn't widen.
+- **`CREATE/ALTER PROCEDURE / FUNCTION / VIEW / TRIGGER / SCHEMA` inside a control-flow body raises Msg 111, not Msg 156**: the must-be-first-statement check is enforced at parse-time per probed wording (PROCEDURE merges CREATE/ALTER into one label; the others use separate `CREATE` / `ALTER` labels). Inside `IF` / `WHILE` / `BEGIN…END`, `BatchContext.BlockDepth > 0` triggers Msg 111; real SQL Server's parser surfaces Msg 156 ("Incorrect syntax near 'procedure'") at the same position. Same end state — the statement is rejected — different error code. Inner CommandText-equivalent contexts (procedure / function / trigger / dynamic-SQL bodies) get a fresh `BatchContext` and the flag resets, so a CREATE PROCEDURE as the first statement of a proc body succeeds (real SQL Server also raises Msg 156 here, a related minor divergence; no real application emits nested CREATE PROCEDUREs).

SqlServerSimulator.Tests.EFCore/EFCoreTriggers.cs

@@ -48,7 +48,8 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
     public void HasTrigger_Insert_FiresAndAuditPopulated()
     {
         var simulation = new Simulation();
-        _ = simulation.ExecuteNonQuery("""
+        simulation.ExecuteBatches(
+            """
             create table Products (
                 Id int identity(1,1) primary key,
                 Name nvarchar(50) not null,
@@ -59,10 +60,12 @@ create table ProductAudit (
                 NewName nvarchar(50) not null,
                 NewPrice int not null
             );
+            """,
+            """
             create trigger tr_product_audit on Products after insert
             as
                 insert ProductAudit(ProductId, NewName, NewPrice)
-                select Id, Name, Price from inserted;
+                select Id, Name, Price from inserted
             """);
         using var context = new TriggerDbContext(simulation);
         _ = context.Products.Add(new Product { Name = "Widget", Price = 100 });
@@ -94,15 +97,18 @@ public void HasTrigger_SaveChanges_RetrievesGeneratedIdentity()
         // round-trip — EF reads Id back from the database after the
         // trigger fires, and the in-memory entity reflects it.
         var simulation = new Simulation();
-        _ = simulation.ExecuteNonQuery("""
+        simulation.ExecuteBatches(
+            """
             create table Products (
                 Id int identity(1,1) primary key,
                 Name nvarchar(50) not null,
                 Price int not null
-            );
+            )
+            """,
+            """
             create trigger tr_product_audit on Products after insert
             as
-                select 1;  -- no-op body; verify identity round-trip works through trigger-safe shape
+                select 1
             """);
         using var context = new TriggerDbContext(simulation);
         var p1 = new Product { Name = "First", Price = 10 };

SqlServerSimulator.Tests.EFCore/EFCoreViews.cs

@@ -16,11 +16,12 @@ public sealed class EFCoreViews
     private static ViewDbContext WithOrderSummary()
     {
         var simulation = new Simulation();
-        _ = simulation.ExecuteNonQuery("""
+        simulation.ExecuteBatches(
+            """
             create table Orders (Id int primary key, Customer varchar(50), Amount decimal(10,2));
             insert Orders values (1, 'Alice', 100.00), (2, 'Bob', 250.00), (3, 'Alice', 50.00);
-            create view OrderSummary as select Customer, sum(Amount) as TotalAmount, count(*) as OrderCount from Orders group by Customer
-            """);
+            """,
+            "create view OrderSummary as select Customer, sum(Amount) as TotalAmount, count(*) as OrderCount from Orders group by Customer");
         return new ViewDbContext(simulation);
     }
 

SqlServerSimulator.Tests/BatchBoundaryTests.cs

@@ -0,0 +1,96 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Verifies <c>CREATE/ALTER PROCEDURE / FUNCTION / VIEW / TRIGGER / SCHEMA</c>
+/// raises Msg 111 ("'X' must be the first statement in a query batch.") when
+/// it isn't the first statement. Probe-confirmed wording per kind: PROCEDURE
+/// merges CREATE / ALTER into one label; the others use their separate
+/// CREATE / ALTER labels. Inner CommandText-equivalent contexts (procedure,
+/// function, trigger, dynamic-SQL bodies) get a fresh BatchContext so the
+/// check naturally resets — proven by the IFBlock + WHILE body cases below
+/// (which raise Msg 111 because BlockDepth &gt; 0).
+/// </summary>
+[TestClass]
+public class BatchBoundaryTests
+{
+    [TestMethod]
+    [DataRow("create schema audit", "create schema staging", "CREATE SCHEMA")]
+    [DataRow("create table t (id int)", "create view v as select 1 as x", "CREATE VIEW")]
+    [DataRow("create table t (id int)", "create function fn() returns int as begin return 1 end", "CREATE FUNCTION")]
+    [DataRow("create table t (id int)", "create proc p as select 1", "CREATE/ALTER PROCEDURE")]
+    [DataRow("create table t (id int)", "create trigger tr on t after insert as select 1", "CREATE TRIGGER")]
+    public void CreateMustBeFirstStatement_RaisesMsg111(string first, string secondCreate, string expectedLabel)
+        => new Simulation().AssertSqlError(
+            $"{first}; {secondCreate}",
+            111,
+            $"'{expectedLabel}' must be the first statement in a query batch.");
+
+    [TestMethod]
+    public void AlterProcedureMustBeFirstStatement_RaisesMsg111()
+    {
+        var simulation = new Simulation();
+        simulation.ExecuteBatches("create proc p as select 1");
+        simulation.AssertSqlError(
+            "declare @x int = 1; alter proc p as select 2",
+            111,
+            "'CREATE/ALTER PROCEDURE' must be the first statement in a query batch.");
+    }
+
+    [TestMethod]
+    public void AlterTriggerMustBeFirstStatement_RaisesMsg111()
+    {
+        var simulation = new Simulation();
+        simulation.ExecuteBatches(
+            "create table t (id int)",
+            "create trigger tr on t after insert as select 1");
+        simulation.AssertSqlError(
+            "declare @x int = 1; alter trigger tr on t after insert as select 2",
+            111,
+            "'ALTER TRIGGER' must be the first statement in a query batch.");
+    }
+
+    [TestMethod]
+    public void CreateOrAlterProcedure_UsesProcedureLabel()
+        => new Simulation().AssertSqlError(
+            "declare @x int = 1; create or alter procedure p as select 2",
+            111,
+            "'CREATE/ALTER PROCEDURE' must be the first statement in a query batch.");
+
+    [TestMethod]
+    public void LeadingSemicolons_DontCountAsFirstStatement()
+        => new Simulation().ExecuteNonQuery("; create proc p as select 1");
+
+    [TestMethod]
+    public void CreateProcInsideIfBlock_RaisesMsg111()
+        => new Simulation().AssertSqlError(
+            "if 1 = 1 begin create proc p as select 1 end",
+            111,
+            "'CREATE/ALTER PROCEDURE' must be the first statement in a query batch.");
+
+    [TestMethod]
+    public void CreateProcInsideWhileBody_RaisesMsg111()
+        => new Simulation().AssertSqlError(
+            "while 1 = 0 begin create proc p as select 1 end",
+            111,
+            "'CREATE/ALTER PROCEDURE' must be the first statement in a query batch.");
+
+    [TestMethod]
+    public void CreateProcAsFirstStatement_Works()
+        => new Simulation().ExecuteNonQuery("create proc p as select 1");
+
+    [TestMethod]
+    public void ProcedureBodyIsItsOwnBatch_AllowsCreateProc()
+    {
+        // Inside a proc body, the dispatched statements form a new batch with
+        // its own BatchContext, so CREATE PROCEDURE may legitimately appear
+        // as the first statement of the body. (Real SQL Server actually
+        // raises Msg 156 syntax error in this position; the simulator's
+        // divergence here is documented and benign — no app emits nested
+        // CREATE PROCEDUREs inside a proc body.)
+        var simulation = new Simulation();
+        simulation.ExecuteBatches(
+            "create proc outer_p as create proc inner_p as select 1",
+            "exec outer_p"); // Invoke the outer proc — its body creates inner_p.
+        Assert.AreEqual(1, simulation.ExecuteScalar("select count(*) from sys.procedures where name = 'inner_p'"));
+    }
+}

SqlServerSimulator.Tests/CatalogViewTests.cs

@@ -38,11 +38,11 @@ select schema_id('audit')
 
     [TestMethod]
     public void SchemaId_TwoUserSchemas_5And6()
-        => AreEqual(11, new Simulation().ExecuteScalar("""
-            create schema audit;
-            create schema staging;
-            select schema_id('audit') + schema_id('staging')
-            """));
+    {
+        var simulation = new Simulation();
+        simulation.ExecuteBatches("create schema audit", "create schema staging");
+        AreEqual(11, simulation.ExecuteScalar("select schema_id('audit') + schema_id('staging')"));
+    }
 
     [TestMethod]
     public void SchemaId_Missing_ReturnsNull()