Statement separators: ; is optional between most statements (declare/select, set/set, insert/select, begin/commit, etc.) — dispatch loop drops the per-iteration MoveNext-at-top, drains explicit ;s, and trusts each parser's lookahead-position

RyanLamansky · RyanLamansky · commit 30771f00d392 · 2026-05-10T13:32:40.000-05:00
contract; IsStatementBoundary normalizes parsers that historically ended on the last consumed token (DBCC's ), SET-session-state's ON/OFF). Two probe-confirmed exceptions stay enforced: WITH directly following another statement raises Msg 319
  (verbatim wording, with the check firing both at top-level dispatch and inside Selection.Parse's projection-element switches so select 0 with cte ... surfaces before the SELECT can complete); MERGE not terminated by ; raises Msg 10713
  immediately after ParseMerge returns. Selection.Parse's pre- and post-projection switches gain statement-keyword terminator cases at depth 0 so back-to-back select 1 select 2 yields two result sets instead of Msg 156, and the same
  WITH-special-case sits next to them. Removes the "implicit statement separation" Not-modeled gap.
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -82,6 +82,13 @@ Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`,
 
 The `*.Tests` and `*.Tests.EFCore` suites are the authoritative behavior contract. Notes below cover only probe-confirmed quirks, deviations from SQL Server, and non-obvious implementation rules.
 
+### Batch grammar: statement separators
+Statements are separated by an optional `;`. Real SQL Server's relaxed grammar lets most statement pairs sit adjacent (`declare @v int = 7 select @v`, `set @v = 1 set @w = 2`, `insert t values (1) select * from t`, `begin tran ... commit`); the simulator follows. Two enforced exceptions match SQL Server's specific rules:
+- A CTE (`WITH`) directly following another statement raises **Msg 319 St 1** (verbatim wording: `Incorrect syntax near the keyword 'with'. If this statement is a common table expression, an xmlnamespaces clause or a change tracking context clause, the previous statement must be terminated with a semicolon.`). A `WITH` at batch start (or right after a `;`) is fine. The check fires both at `Simulation.CreateResultSetsForCommand`'s top-level dispatch (`requireSemicolonBeforeCte` flag) and inside `Selection.Parse`'s projection-element switches — the latter is where `select 0 with cte ...` surfaces it before the SELECT can complete.
+- A `MERGE` not terminated by `;` raises **Msg 10713 St 1** (`A MERGE statement must be terminated by a semi-colon (;).`) regardless of whether another statement follows or the batch ends. The check sits at the dispatch site immediately after `ParseMerge` returns, before any cursor normalization.
+
+The dispatch loop drains optional `;`s at the top of each iteration and trusts each parser to leave `Token` at its first un-consumed token (the `ParserContext` lookahead-position contract). Parsers that historically ended on the last token they consumed (DBCC's closing `)`, SET-session-state's `ON`/`OFF`) get a one-token advance via `IsStatementBoundary` after dispatch — Token already at `;`, end-of-batch, or a recognized statement-starting keyword is left alone.
+
 ### Boolean / set ops / projection / CASE
 - Boolean combinators (WHERE / MERGE-ON / CHECK): `AND` / `OR` / `NOT`, parens, `IS [NOT] NULL`, `[NOT] IN (literal,...)`. Tri-valued.
 - Set ops (UNION / UNION ALL / INTERSECT / EXCEPT): standard precedence (INTERSECT > UNION/EXCEPT). **NULLs are equal during set-op dedup/matching** (opposite of `=`'s tri-state). Per-branch ORDER BY in non-final branch → Msg 156. Top-level ORDER BY references first-branch column names only.
@@ -267,7 +274,7 @@ Variable references resolve at runtime via a captured `VariableSlot` — require
 
 **`@@ROWCOUNT`**: tracks the most-recently-completed statement's row count via `Simulation.LastStatementRowCount`. SELECT row counts populate after the dispatch materializes rows up-front (so the next statement in the batch sees the final count); DML mutations write their affected count; `SET` / `DECLARE @v = init` write 1; bare `DECLARE @v` (no initializer) preserves the prior count; transaction / DDL statements reset to 0.
 
-**Compound assignment** (`SET @v += expr` etc.) and **table variables** (`DECLARE @t TABLE (...)`) aren't modeled — rewrite as `SET @v = @v + expr` for the former; the latter is a separate bundle. Statements within a batch require `;` separators (existing simulator-wide convention; real SQL Server accepts implicit separation in many cases).
+**Compound assignment** (`SET @v += expr` etc.) and **table variables** (`DECLARE @t TABLE (...)`) aren't modeled — rewrite as `SET @v = @v + expr` for the former; the latter is a separate bundle.
 
 ### Common table expressions
 `WITH name [(col, …)] AS (SELECT …) [, …] {SELECT|INSERT|UPDATE|DELETE|MERGE} …`. WITH prefix scopes to exactly one immediately-following statement. Both non-recursive and recursive forms modeled.
@@ -352,7 +359,6 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - Table variables (`DECLARE @t TABLE (...)`) — separate feature with its own storage / scope / lifecycle.
 - T-SQL control flow (`IF` / `WHILE` / `BEGIN ... END` / `BREAK` / `CONTINUE`) — Bundle 2 of scripting.
 - `TRY ... CATCH`, `THROW`, `RAISERROR`, `@@ERROR`, `RETURN`, `PRINT`, stored procs / UDFs.
-- Implicit statement separation: real SQL Server accepts `declare @v int = 7 select @v` without `;`; simulator requires explicit semicolons between statements when one ends with an expression.
 - `hierarchyid`, `geography`, `geometry`.
 
 ## Quirks (modeled, not byte-identical to SQL Server)
diff --git a/SqlServerSimulator.Tests/OptionalSemicolonTests.cs b/SqlServerSimulator.Tests/OptionalSemicolonTests.cs
@@ -0,0 +1,198 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public sealed class OptionalSemicolonTests
+{
+    [TestMethod]
+    public void DeclareThenSelect_NoSeparator_Works()
+        => AreEqual(7, ExecuteScalar<int>("declare @v int = 7 select @v"));
+
+    [TestMethod]
+    public void SetThenSet_NoSeparator_Works()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("declare @v int, @w int set @v = 1 set @w = 2 select @v + @w");
+        AreEqual(3, cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void SelectThenSelect_NoSeparator_YieldsTwoResultSets()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("select 1 as a select 2 as b");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+        IsTrue(reader.NextResult());
+        IsTrue(reader.Read());
+        AreEqual(2, reader.GetInt32(0));
+    }
+
+    [TestMethod]
+    public void InsertThenSelect_NoSeparator_Works()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table t (id int)").ExecuteNonQuery();
+        AreEqual(1, conn.CreateCommand("insert t values (1) select count(*) from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void BeginTranThenRollback_NoSeparator_Works()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int)");
+        _ = sim.ExecuteNonQuery("begin tran insert t values (1) rollback");
+        AreEqual(0, sim.ExecuteScalar<int>("select count(*) from t"));
+    }
+
+    [TestMethod]
+    public void CreateInsertSelect_NoSeparators_Works()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        AreEqual(1, conn.CreateCommand(
+            "create table t (id int) insert t values (1) select count(*) from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void NewlineBetweenStatements_NoSeparator_Works()
+        => AreEqual(7, ExecuteScalar<int>("declare @v int = 7\nselect @v"));
+
+    [TestMethod]
+    public void DoubleSemicolon_Works()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("select 1 as a;;select 2 as b");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+        IsTrue(reader.NextResult());
+        IsTrue(reader.Read());
+        AreEqual(2, reader.GetInt32(0));
+    }
+
+    [TestMethod]
+    public void TrailingSemicolons_Works()
+        => AreEqual(1, ExecuteScalar<int>("select 1;;;"));
+
+    [TestMethod]
+    public void LeadingSemicolons_Works()
+        => AreEqual(1, ExecuteScalar<int>(";;select 1"));
+
+    [TestMethod]
+    public void EmptyBatchOfSemicolons_NoOp()
+    {
+        // SqlClient's ExecuteNonQuery returns -1 when no DML statement ran;
+        // a batch of bare `;`s should produce that sentinel rather than
+        // throwing.
+        using var conn = new Simulation().CreateOpenConnection();
+        AreEqual(-1, conn.CreateCommand(";;").ExecuteNonQuery());
+    }
+
+    [TestMethod]
+    public void CteAtBatchStart_NoSemicolonNeeded()
+        => AreEqual(1, ExecuteScalar<int>("with cte as (select 1 as x) select x from cte"));
+
+    [TestMethod]
+    public void CteAfterSemicolon_Works()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("select 0 as a;with cte as (select 1 as x) select x from cte");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(0, reader.GetInt32(0));
+        IsTrue(reader.NextResult());
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+    }
+
+    [TestMethod]
+    public void CteWithoutPrecedingSemicolon_RaisesMsg319()
+        => AssertSqlError(
+            "select 0 as a with cte as (select 1 as x) select x from cte",
+            319,
+            "Incorrect syntax near the keyword 'with'. If this statement is a common table expression, an xmlnamespaces clause or a change tracking context clause, the previous statement must be terminated with a semicolon.");
+
+    [TestMethod]
+    public void TwoCtesWithoutSemicolon_RaisesMsg319()
+    {
+        // Even when both statements are CTE-prefixed, the second WITH still
+        // requires a `;` to separate it from the prior statement. The error
+        // surfaces when the dispatch loop advances to the second WITH —
+        // which means the test has to drive iteration past the first result
+        // set; ExecuteScalar would short-circuit.
+        using var conn = new Simulation().CreateOpenConnection();
+        var ex = Throws<System.Data.Common.DbException>(() =>
+            conn.CreateCommand(
+                "with c1 as (select 1 as x) select x from c1 with c2 as (select 2 as y) select y from c2")
+                .ExecuteNonQuery());
+        AreEqual("319", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void MergeWithTrailingSemicolon_Works()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table dst (id int)");
+        _ = sim.ExecuteNonQuery("merge dst using (values (1)) v(x) on 1=0 when not matched then insert (id) values (v.x);");
+        AreEqual(1, sim.ExecuteScalar<int>("select count(*) from dst"));
+    }
+
+    [TestMethod]
+    public void MergeWithoutTrailingSemicolon_RaisesMsg10713()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table dst (id int)");
+        sim.AssertSqlError(
+            "merge dst using (values (1)) v(x) on 1=0 when not matched then insert (id) values (v.x)",
+            10713,
+            "A MERGE statement must be terminated by a semi-colon (;).");
+    }
+
+    [TestMethod]
+    public void MergeFollowedByAnotherStatementWithoutTerminator_RaisesMsg10713()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table dst (id int)");
+        _ = sim.AssertSqlError(
+            "merge dst using (values (1)) v(x) on 1=0 when not matched then insert (id) values (v.x) select 1",
+            10713);
+    }
+
+    [TestMethod]
+    public void MergeThenSelectWithSemicolon_Works()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table dst (id int)").ExecuteNonQuery();
+        AreEqual(
+            1,
+            conn.CreateCommand(
+                "merge dst using (values (1)) v(x) on 1=0 when not matched then insert (id) values (v.x);select count(*) from dst")
+            .ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void DbccFollowedBySelect_NoSeparator_Works()
+    {
+        // DBCC TRACEON's parser ends on the closing `)` (last consumed) rather
+        // than the lookahead. The dispatch loop normalizes by advancing one
+        // token when the cursor isn't already at a statement boundary; this
+        // test exercises that path.
+        AreEqual(1, ExecuteScalar<int>("dbcc traceon(460) select 1"));
+    }
+
+    [TestMethod]
+    public void AlterDatabaseFollowedBySelect_NoSeparator_Works()
+        => AreEqual(2, ExecuteScalar<int>(
+            "alter database current set compatibility_level = 160 select 2"));
+
+    [TestMethod]
+    public void DeclareSetSelect_NoSeparators_Works()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        AreEqual(15, conn.CreateCommand(
+            "declare @x int = 7 set @x = @x + 8 select @x").ExecuteScalar());
+    }
+}
diff --git a/SqlServerSimulator/Errors/SimulatedSqlException.SyntaxErrors.cs b/SqlServerSimulator/Errors/SimulatedSqlException.SyntaxErrors.cs
@@ -47,4 +47,29 @@ internal static SimulatedSqlException NoCorrespondingBeginCommit() =>
     /// </summary>
     internal static SimulatedSqlException NoCorrespondingBeginRollback() =>
         new("The ROLLBACK TRANSACTION request has no corresponding BEGIN TRANSACTION.", 3903, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 319: a CTE-prefixed statement (a <c>WITH</c>
+    /// clause introducing a common table expression) followed another
+    /// statement with no <c>;</c> separator. Probe-confirmed verbatim text /
+    /// Class 15 / State 1. The wording is structural: real SQL Server lists
+    /// every grammar slot where <c>WITH</c> appears (CTE, xmlnamespaces,
+    /// change-tracking context) since the parser can't distinguish at this
+    /// point. A <c>WITH</c> at batch start, or immediately after a <c>;</c>,
+    /// is fine — only a back-to-back <c>statement WITH cte</c> sequence
+    /// triggers this.
+    /// </summary>
+    internal static SimulatedSqlException CteRequiresPrecedingSemicolon() =>
+        new("Incorrect syntax near the keyword 'with'. If this statement is a common table expression, an xmlnamespaces clause or a change tracking context clause, the previous statement must be terminated with a semicolon.", 319, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 10713: a <c>MERGE</c> statement was not
+    /// followed by a <c>;</c>. Probe-confirmed verbatim text (note the
+    /// hyphenated <c>"semi-colon"</c>) / Class 15 / State 1. <c>MERGE</c> is
+    /// the only statement family the server requires to be terminated with a
+    /// semicolon, regardless of whether another statement follows or the
+    /// batch ends.
+    /// </summary>
+    internal static SimulatedSqlException MergeMustBeTerminated() =>
+        new("A MERGE statement must be terminated by a semi-colon (;).", 10713, 15, 1);
 }
diff --git a/SqlServerSimulator/Parser/Selection.cs b/SqlServerSimulator/Parser/Selection.cs
@@ -373,6 +373,31 @@ private static Selection ParseInner(ParserContext context, uint depth, List<Aggr
                 case ReservedKeyword { Keyword: Keyword.Union or Keyword.Intersect or Keyword.Except }:
                     goto ExitWhileTokenLoop;
 
+                // At the top level (depth 0), the start of another statement
+                // terminates this SELECT and lets the dispatch loop pick up
+                // where it left off. Real SQL Server allows back-to-back
+                // statements without `;` between them; we mirror by stopping
+                // the projection-list parse here. Inside a subquery (depth > 0)
+                // these keywords are still invalid — fall through to the
+                // generic Msg 156 catch-all below.
+                case Operator { Character: ';' } when depth == 0:
+                case ReservedKeyword
+                {
+                    Keyword: Keyword.Select or Keyword.Insert or Keyword.Update or Keyword.Delete
+                        or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
+                        or Keyword.Save or Keyword.Create or Keyword.Alter or Keyword.Dbcc
+                        or Keyword.Set or Keyword.Declare
+                } when depth == 0:
+                    goto ExitWhileTokenLoop;
+
+                // WITH at the start of a projection element is unambiguous:
+                // it can only mean a CTE-prefixed follow-up statement. Real
+                // SQL Server raises Msg 319 here rather than the generic
+                // Msg 156 from the catch-all below — telling the user to
+                // separate statements with `;`.
+                case ReservedKeyword { Keyword: Keyword.With } when depth == 0:
+                    throw SimulatedSqlException.CteRequiresPrecedingSemicolon();
+
                 case ReservedKeyword { Keyword: not Keyword.Null } keyword:
                     throw SimulatedSqlException.SyntaxErrorNearKeyword(keyword);
 
@@ -481,6 +506,25 @@ private static Selection ParseInner(ParserContext context, uint depth, List<Aggr
                 // driver (ParseQueryExpression) can chain branches.
                 case ReservedKeyword { Keyword: Keyword.Union or Keyword.Intersect or Keyword.Except }:
                     goto ExitWhileTokenLoop;
+
+                // At the top level (depth 0), the start of another statement
+                // terminates this SELECT — the dispatch loop picks up there.
+                // Inside a subquery these keywords stay invalid (fall through
+                // to the generic Msg 102 below).
+                case ReservedKeyword
+                {
+                    Keyword: Keyword.Select or Keyword.Insert or Keyword.Update or Keyword.Delete
+                        or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
+                        or Keyword.Save or Keyword.Create or Keyword.Alter or Keyword.Dbcc
+                        or Keyword.Set or Keyword.Declare
+                } when depth == 0:
+                    goto ExitWhileTokenLoop;
+
+                // WITH at the projection-element-end position can only mean a
+                // CTE-prefixed follow-up statement; raise Msg 319 to mirror
+                // SQL Server's specific error here.
+                case ReservedKeyword { Keyword: Keyword.With } when depth == 0:
+                    throw SimulatedSqlException.CteRequiresPrecedingSemicolon();
             }
 
             throw SimulatedSqlException.SyntaxErrorNear(context);
diff --git a/SqlServerSimulator/Simulation/Simulation.cs b/SqlServerSimulator/Simulation/Simulation.cs
