Unify the four drifted statement-boundary keyword sets into one IsStatementBoundary predicate so semicolon-less statement sequences parse for the full statement-keyword set.

Author: RyanLamansky

SqlServerSimulator.Tests/StatementBoundaryTests.cs

@@ -0,0 +1,143 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Semicolon-less statement sequences: SQL Server accepts one statement
+/// immediately followed by another with no separating <c>;</c>, and SSMS
+/// generates such batches. The simulator recognizes the second statement's
+/// leading keyword through a single shared predicate
+/// (<c>Simulation.IsStatementBoundary</c>) that every consumer — the dispatch
+/// loop, the SELECT projection-list terminator, the EXEC-argument scanner, and
+/// the principal-DDL parse-and-discard tail — routes through, so the full
+/// statement-keyword set (including <c>EXEC</c>/<c>EXECUTE</c>, <c>USE</c>,
+/// <c>GRANT</c>, <c>FETCH</c>, …) terminates the preceding statement uniformly.
+/// The cross-product below pairs each kind of preceding statement with each
+/// kind of following statement, joined by a newline only, and proves the batch
+/// parses and runs to the trailing sentinel <c>SELECT 42</c>.
+/// </summary>
+[TestClass]
+public sealed class StatementBoundaryTests
+{
+    // Shared prelude gives every combination a table, a declared+opened
+    // cursor, and an @rc slot so FETCH / GRANT / EXEC @rc all have targets.
+    // The load-bearing junction is the newline-only join between the
+    // preceding and following statements — no `;` separates them. The trailing
+    // SELECT 42 sentinel is read from the LAST result set (a following such as
+    // SELECT / FETCH emits its own result set first), proving the whole batch
+    // parsed and ran to completion; pre-fix these threw Msg 102.
+    private static int RunPair(string preceding, string following)
+    {
+        using var reader = new Simulation().ExecuteReader($"""
+            create table t (id int not null);
+            insert into t values (1);
+            declare @rc int;
+            declare c cursor for select id from t;
+            open c;
+            {preceding}
+            {following};
+            select 42
+            """);
+        object? last = null;
+        do
+        {
+            while (reader.Read())
+                last = reader[0];
+        }
+        while (reader.NextResult());
+        return (int)last!;
+    }
+
+    [TestMethod]
+    [DataRow("select 1")]
+    [DataRow("declare @x int")]
+    [DataRow("if 1 = 1 select 1")]
+    [DataRow("set nocount on")]
+    [DataRow("insert into t values (2)")]
+    public void FollowedByExecProc_NoSemicolon_Parses(string preceding)
+        => AreEqual(42, RunPair(preceding, "exec xp_qv N'a', N'b'"));
+
+    [TestMethod]
+    [DataRow("select 1")]
+    [DataRow("declare @x int")]
+    [DataRow("if 1 = 1 select 1")]
+    [DataRow("set nocount on")]
+    [DataRow("insert into t values (2)")]
+    public void FollowedByExecReturnCapture_NoSemicolon_Parses(string preceding)
+        => AreEqual(42, RunPair(preceding, "exec @rc = xp_qv N'a', N'b'"));
+
+    [TestMethod]
+    [DataRow("select 1")]
+    [DataRow("declare @x int")]
+    [DataRow("if 1 = 1 select 1")]
+    [DataRow("set nocount on")]
+    [DataRow("insert into t values (2)")]
+    public void FollowedByUse_NoSemicolon_Parses(string preceding)
+        => AreEqual(42, RunPair(preceding, "use master"));
+
+    [TestMethod]
+    [DataRow("select 1")]
+    [DataRow("declare @x int")]
+    [DataRow("if 1 = 1 select 1")]
+    [DataRow("set nocount on")]
+    [DataRow("insert into t values (2)")]
+    public void FollowedByGrant_NoSemicolon_Parses(string preceding)
+        => AreEqual(42, RunPair(preceding, "grant select on t to public"));
+
+    [TestMethod]
+    [DataRow("select 1")]
+    [DataRow("declare @x int")]
+    [DataRow("if 1 = 1 select 1")]
+    [DataRow("set nocount on")]
+    [DataRow("insert into t values (2)")]
+    public void FollowedByFetch_NoSemicolon_Parses(string preceding)
+        => AreEqual(42, RunPair(preceding, "fetch c"));
+
+    [TestMethod]
+    [DataRow("select 1")]
+    [DataRow("declare @x int")]
+    [DataRow("if 1 = 1 select 1")]
+    [DataRow("set nocount on")]
+    [DataRow("insert into t values (2)")]
+    public void FollowedBySelect_NoSemicolon_Parses(string preceding)
+        => AreEqual(42, RunPair(preceding, "select 1"));
+
+    // WITH after a SELECT projection stays the specific Msg 319 ("Incorrect
+    // syntax near … expects a preceding statement terminated with a
+    // semicolon") rather than being swallowed as a generic boundary — the
+    // CTE-continuation case is checked ahead of the shared boundary predicate.
+    [TestMethod]
+    public void SelectFollowedByCte_WithoutSemicolon_RaisesMsg319()
+        => new Simulation().AssertSqlError(
+            "select 1 with x as (select 1 as n) select n from x",
+            319);
+
+    // The exact SSMS Object-Explorer AlwaysOn availability probe: three
+    // statements, only the middle two separated by a semicolon. xp_qv returns
+    // status 0 (AlwaysOn not available), so ISNULL(@alwayson, -1) yields 0.
+    [TestMethod]
+    public void SsmsAlwaysOnProbe_ReturnsZero()
+        => AreEqual(0, new Simulation().ExecuteScalar<int>("""
+            DECLARE @alwayson INT
+            EXECUTE @alwayson = master.dbo.xp_qv N'3641190370', @@SERVICENAME;
+            SELECT ISNULL(@alwayson,-1) AS [AlwaysOn]
+            """));
+
+    [TestMethod]
+    [DataRow("exec xp_qv N'x', N'y'")]
+    [DataRow("exec dbo.xp_qv N'x', N'y'")]
+    [DataRow("exec master.dbo.xp_qv N'x', N'y'")]
+    public void XpQv_YieldsNoResultSet(string call)
+    {
+        using var reader = new Simulation().ExecuteReader(call);
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void XpQv_ReturnStatus_IsZero()
+        => AreEqual(0, new Simulation().ExecuteScalar<int>("""
+            declare @rc int;
+            exec @rc = xp_qv N'x', N'y';
+            select @rc
+            """));
+}

SqlServerSimulator/Parser/Selection.cs

@@ -560,6 +560,16 @@ private static Selection ParseInner(ParserContext context, uint depth, List<Aggr
                 case ReservedKeyword { Keyword: Keyword.Union or Keyword.Intersect or Keyword.Except or Keyword.Option }:
                     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 `;`. Checked before the general
+                // statement-boundary case (which also treats WITH as a
+                // boundary) so the more specific Msg 319 wins.
+                case ReservedKeyword { Keyword: Keyword.With } when depth == 0:
+                    throw SimulatedSqlException.CteRequiresPrecedingSemicolon();
+
                 // 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
@@ -568,24 +578,9 @@ private static Selection ParseInner(ParserContext context, uint depth, List<Aggr
                 // 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.Drop or Keyword.Alter or Keyword.Dbcc
-                        or Keyword.Set or Keyword.Declare or Keyword.If or Keyword.Else or Keyword.End
-                        or Keyword.While or Keyword.Break or Keyword.Continue or Keyword.Return
-                        or Keyword.Print or Keyword.WaitFor or Keyword.Truncate
-                } 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 statementStart when depth == 0 && Simulation.IsStatementBoundary(statementStart):
+                    goto ExitWhileTokenLoop;
 
                 case ReservedKeyword { Keyword: not Keyword.Null } keyword:
                     throw SimulatedSqlException.SyntaxErrorNearKeyword(keyword);
@@ -765,26 +760,20 @@ or Keyword.Print or Keyword.WaitFor or Keyword.Truncate
                 case ReservedKeyword { Keyword: Keyword.Union or Keyword.Intersect or Keyword.Except or Keyword.Option }:
                     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. Checked before the general
+                // statement-boundary case (which also treats WITH as a
+                // boundary) so the more specific Msg 319 wins.
+                case ReservedKeyword { Keyword: Keyword.With } when depth == 0:
+                    throw SimulatedSqlException.CteRequiresPrecedingSemicolon();
+
                 // 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.Drop or Keyword.Alter or Keyword.Dbcc
-                        or Keyword.Set or Keyword.Declare or Keyword.If or Keyword.Else or Keyword.End
-                        or Keyword.While or Keyword.Break or Keyword.Continue or Keyword.Return
-                        or Keyword.Print or Keyword.WaitFor or Keyword.Truncate
-                } when depth == 0:
+                case ReservedKeyword statementStart when depth == 0 && Simulation.IsStatementBoundary(statementStart):
                     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);

SqlServerSimulator/Simulation/Simulation.Exec.cs

@@ -58,6 +58,12 @@ partial class Simulation
                 // here from any current database (real SQL Server resolves
                 // sp_/xp_ system procs through master).
                 "xp_msver",
+                // xp_qv is SSMS's AlwaysOn-availability probe. It yields no
+                // result set and returns status 0; the simulator reports
+                // AlwaysOn as not-available (consistent with
+                // SERVERPROPERTY('IsHadrEnabled') = 0), so the @rc capture
+                // lands 0 and Object Explorer's Databases node populates.
+                "xp_qv",
             ],
             collation);
         return lookup.TryGetValue(leaf, out var canonical) ? canonical : null;
@@ -152,6 +158,7 @@ private IEnumerable<SimulatedStatementOutcome> ParseExec(BatchContext batch)
             "sp_set_session_context" => InvokeSpSetSessionContext(batch),
             "sp_updateextendedproperty" => InvokeSpExtendedProperty(batch, ExtendedPropertyOp.Update),
             "xp_msver" => InvokeXpMsver(batch),
+            "xp_qv" => InvokeXpQv(batch, returnCodeVar),
             _ => throw new InvalidOperationException($"{systemProcName} is in SystemProcedureNames but has no dispatch arm."),
         };
         if (systemProc is not null)
@@ -188,7 +195,7 @@ private static List<ProcArgument> ParseExecArguments(ParserContext context, Batc
         var arguments = new List<ProcArgument>();
         // No args at all — return empty list. The terminator is either `;`,
         // end-of-batch, or a statement-starting keyword.
-        if (IsExecArgumentBoundary(context.Token))
+        if (IsStatementBoundary(context.Token))
             return arguments;
 
         var sawNamed = false;
@@ -262,6 +269,18 @@ private static ProcArgument ParseExecArgument(ParserContext context, BatchContex
             return new ProcArgument(name, isDefault: true, value: SqlValue.Null(SqlType.Int32), outputSlot: null);
         }
 
+        // @@-prefixed niladic function (e.g. @@SERVICENAME, which SSMS's
+        // AlwaysOn probe passes to xp_qv). Evaluate the single atom in a
+        // column-less runtime context; session-state forms (@@SPID /
+        // @@ROWCOUNT / …) read their live value through the batch.
+        if (context.Token is DoubleAtPrefixedString)
+        {
+            var expression = Expression.Parse(context);
+            var value = expression.Run(new RuntimeContext(
+                columnName => throw SimulatedSqlException.ColumnReferenceNotAllowed(columnName), batch));
+            return new ProcArgument(name, isDefault: false, value: value, outputSlot: null);
+        }
+
         // @variable reference — capture the slot (live, so OUTPUT writeback
         // sees the proc's final value), read its value now, and check for a
         // trailing OUTPUT / OUT keyword. When the name resolves to a table
@@ -328,12 +347,6 @@ private static SqlValue NegateLiteral(SqlValue v) =>
         : v.Type == SqlType.BigInt ? SqlValue.FromInt64(-v.AsInt64)
         : v.Type == SqlType.SmallInt ? SqlValue.FromInt16((short)-v.AsInt32)
         : v;
-
-    private static bool IsExecArgumentBoundary(Token? token) =>
-        token is null
-        or Operator { Character: ';' }
-        or 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.Drop or Keyword.Alter or Keyword.Dbcc or Keyword.Set or Keyword.Declare or Keyword.With or Keyword.If or Keyword.Else or Keyword.End or Keyword.While or Keyword.Break or Keyword.Continue or Keyword.Return or Keyword.Print or Keyword.RaisError or Keyword.WaitFor or Keyword.Truncate or Keyword.Exec or Keyword.Execute }
-        or UnquotedString { ContextualKeyword: ContextualKeyword.Throw };
 }
 
 /// <summary>

SqlServerSimulator/Simulation/Simulation.PrincipalDdl.cs

@@ -165,20 +165,7 @@ internal static bool TryParseDropUser(ParserContext context)
     /// </summary>
     private static void ConsumeToStatementBoundary(ParserContext context)
     {
-        while (context.Token is not (null
-            or Operator { Character: ';' }
-            or 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.Drop or Keyword.Alter or Keyword.Dbcc
-                    or Keyword.Set or Keyword.Declare or Keyword.With or Keyword.If or Keyword.Else
-                    or Keyword.End or Keyword.While or Keyword.Break or Keyword.Continue
-                    or Keyword.Return or Keyword.Print or Keyword.RaisError or Keyword.WaitFor
-                    or Keyword.Truncate or Keyword.Grant or Keyword.Revoke or Keyword.Deny
-            }))
-        {
+        while (!IsStatementBoundary(context.Token))
             context.MoveNextOptional();
-        }
     }
 }

SqlServerSimulator/Simulation/Simulation.XpQv.cs

@@ -0,0 +1,30 @@
+using SqlServerSimulator.Parser;
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator;
+
+partial class Simulation
+{
+    /// <summary>
+    /// Handles <c>EXEC xp_qv</c> (also <c>dbo.xp_qv</c> /
+    /// <c>master.dbo.xp_qv</c> from any current database), SSMS's AlwaysOn-
+    /// availability probe (<c>EXECUTE @rc = master.dbo.xp_qv N'&lt;hash&gt;',
+    /// @@SERVICENAME</c>). Consumes and ignores its arguments (the feature
+    /// hash isn't validated), yields no result set, and returns status 0.
+    /// A real HADR-enabled instance returns 2; the simulator deliberately
+    /// reports not-available, matching <c>SERVERPROPERTY('IsHadrEnabled')</c>
+    /// = 0, so <c>SELECT ISNULL(@rc, -1)</c> yields 0 and Object Explorer's
+    /// Databases node populates instead of the SMO probe aborting.
+    /// </summary>
+    private static IEnumerable<SimulatedStatementOutcome> InvokeXpQv(BatchContext batch, string? returnCodeVariableName)
+    {
+        _ = ParseExecArguments(batch.Parser, batch);
+        if (batch.IsSkipping)
+            yield break;
+        if (returnCodeVariableName is not null)
+        {
+            var slot = batch.GetVariableSlot(returnCodeVariableName);
+            slot.Value = SqlValue.FromInt32(0).CoerceTo(slot.DeclaredType);
+        }
+    }
+}

SqlServerSimulator/Simulation/Simulation.cs

@@ -1380,8 +1380,16 @@ private IEnumerable<SimulatedStatementOutcome> DispatchOneStatementCore(BatchCon
     /// batch, a recognized statement-starting keyword, or the <c>END</c>
     /// terminator of a BEGIN…END block. Used to decide whether to re-normalize
     /// a parser's leftover cursor position.
+    ///
+    /// This is the single source of truth for "does this token begin a new
+    /// top-level statement (or a hard boundary)?" — the dispatch loop, the
+    /// EXEC-argument scanner, the principal-DDL parse-and-discard tail, and the
+    /// SELECT projection-list terminator all route through it, so a new
+    /// statement keyword is added in exactly one place. SQL Server accepts
+    /// back-to-back statements without a separating <c>;</c>; every consumer
+    /// mirrors that by treating the full keyword set uniformly as a boundary.
     /// </summary>
-    private static bool IsStatementBoundary(Token? token) =>
+    internal static bool IsStatementBoundary(Token? token) =>
         token is null
         or Operator { Character: ';' }
         or ReservedKeyword
@@ -1394,6 +1402,7 @@ or Keyword.End or Keyword.While or Keyword.Break or Keyword.Continue
                 or Keyword.Return or Keyword.Print or Keyword.RaisError or Keyword.WaitFor
                 or Keyword.Truncate or Keyword.Use or Keyword.Grant or Keyword.Revoke or Keyword.Deny
                 or Keyword.Open or Keyword.Fetch or Keyword.Close or Keyword.Deallocate
+                or Keyword.Exec or Keyword.Execute
         }
         // THROW is a contextual keyword in SQL Server's grammar — added with
         // the TRY/CATCH companion feature in 2012, not in the reserved list.