Live SSMS shakedown fixes spanning Table Designer, Activity Monitor, and standard reports: dynamic SQL executed via EXEC()/sp_executesql brackets its statements with real's nested-proc token discipline (DONEINPROC per statement, RETURNSTATUS 0 + DONEPROC on scope exit), the simulator's version identity becomes the reference build 17.0.4065.4 across SERVERPROPERTY/@@VERSION/@@MICROSOFTVERSION/LOGINACK/prelogin with xp_msver rows pinned to the probed reference output, parenthesized join groups in FROM parse and execute as SysP partition catalog views already shipped, the legacy permissions() bitmap, sys.assembly_types and sys.columns gain their missing real columns, COLLATE database_default/catalog_default resolve as bind-time keywords, Msg 207 prints only the leaf column name like real, and SERVERPROPERTY ProcessID/ComputerNamePhysicalNetBIOS return the host process id and machine placeholder instead of the NULLs Activity Monitor crashes casting.

Author: RyanLamansky

SqlServerSimulator.Tests.Internal/ProcScopeBoundaryTests.cs

@@ -0,0 +1,75 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Pins the outcome-stream markers that drive the TDS endpoint's DONEINPROC /
+/// RETURNSTATUS / DONEPROC discipline for an <c>EXEC('…')</c> / sp_executesql
+/// dynamic-SQL scope. Real SQL Server runs such a body as a nested procedure
+/// scope — its statements report DONEINPROC (0xFF) and the scope closes with
+/// RETURNSTATUS + DONEPROC — where the simulator previously emitted a plain
+/// batch DONE (0xFD). The engine now brackets the dynamic body's outcomes with
+/// <see cref="SimulatedProcScopeBoundary"/> markers (Enter / Exit) that
+/// <c>StreamOutcomesAsync</c> consumes; every in-process consumer ignores them.
+/// Token-level shape captured cleartext against SQL Server 2025 (2026-07-19).
+/// </summary>
+[TestClass]
+public sealed class ProcScopeBoundaryTests
+{
+    private static List<SimulatedStatementOutcome> Outcomes(string sql)
+    {
+        var simulation = new Simulation();
+        using var connection = simulation.CreateDbConnection();
+        connection.Open();
+        using var command = connection.CreateCommand();
+        command.CommandText = sql;
+        return [.. simulation.CreateResultSetsForCommand(command)];
+    }
+
+    private static string Shape(SimulatedStatementOutcome outcome) => outcome switch
+    {
+        SimulatedProcScopeBoundary { IsEnter: true } => "ENTER",
+        SimulatedProcScopeBoundary => "EXIT",
+        SimulatedQueryResult => "QUERY",
+        _ => "OTHER",
+    };
+
+    [TestMethod]
+    public void ExecString_BracketsInnerOutcomesWithEnterAndExitMarkers()
+    {
+        var shapes = Outcomes("select 1 as a; exec('select 2 as b'); select 3 as c").Select(Shape).ToList();
+
+        CollectionAssert.AreEqual(new[] { "QUERY", "ENTER", "QUERY", "EXIT", "QUERY" }, shapes);
+    }
+
+    [TestMethod]
+    public void ExecString_WithNoResultSet_StillBracketsScope()
+    {
+        // A body that produces no result set must still open and close the scope
+        // (real emits RETURNSTATUS + DONEPROC even with no DONEINPROC in between).
+        var boundaries = Outcomes("exec('declare @x int; set @x = 1')")
+            .OfType<SimulatedProcScopeBoundary>()
+            .Select(b => b.IsEnter)
+            .ToList();
+
+        CollectionAssert.AreEqual(new[] { true, false }, boundaries);
+    }
+
+    [TestMethod]
+    public void SpExecuteSql_BracketsScope()
+    {
+        var shapes = Outcomes("exec sp_executesql N'select 42 as answer'").Select(Shape).ToList();
+
+        AreEqual("ENTER", shapes[0]);
+        AreEqual("QUERY", shapes[1]);
+        AreEqual("EXIT", shapes[^1]);
+    }
+
+    [TestMethod]
+    public void BatchWithoutExec_HasNoBoundaryMarkers()
+    {
+        var boundaries = Outcomes("select 1; select 2").OfType<SimulatedProcScopeBoundary>().Count();
+
+        AreEqual(0, boundaries);
+    }
+}

SqlServerSimulator.Tests.SqlClient/DynamicSqlExecWireTests.cs

@@ -0,0 +1,88 @@
+using Microsoft.Data.SqlClient;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end wire coverage for <c>EXEC('…')</c> dynamic SQL inside a SQLBatch.
+/// Real SQL Server runs the dynamic body as a nested procedure scope: its
+/// statements report DONEINPROC (0xFF) and the scope closes with RETURNSTATUS +
+/// DONEPROC, where the simulator previously emitted a plain batch DONE (0xFD).
+/// The SSMS report viewer's environment-probe batch (whose final result set
+/// comes from an <c>EXEC('…')</c>) froze .NET Framework's stricter native TDS
+/// parser on the old shape; these tests drive the same shape over real SqlClient
+/// so the corrected token stream stays well-formed. Real-server token shape
+/// captured cleartext 2026-07-19.
+/// </summary>
+[TestClass]
+public sealed class DynamicSqlExecWireTests
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public async Task ExecInBatch_AfterBatchLevelSelects_AllResultSetsRead()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        // Batch-level SELECTs (plain DONE) followed by an EXEC('…') result set
+        // (DONEINPROC + RETURNSTATUS + DONEPROC) — the report-viewer shape.
+        const string batch = "select 1 as a; select 2 as b; exec('select 3 as c')";
+        await using var command = new SqlCommand(batch, connection);
+        await using var reader = await command.ExecuteReaderAsync(TestContext.CancellationToken);
+
+        var seen = new List<(string Column, int Value)>();
+        do
+        {
+            while (await reader.ReadAsync(TestContext.CancellationToken))
+                seen.Add((reader.GetName(0), reader.GetInt32(0)));
+        }
+        while (await reader.NextResultAsync(TestContext.CancellationToken));
+
+        CollectionAssert.AreEqual(
+            new[] { ("a", 1), ("b", 2), ("c", 3) },
+            seen);
+    }
+
+    [TestMethod]
+    public async Task ReportViewerEnvironmentProbe_ThreeResultSets()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        await using (var lockTimeout = new SqlCommand("SET LOCK_TIMEOUT 10000", connection))
+            _ = await lockTimeout.ExecuteNonQueryAsync(TestContext.CancellationToken);
+
+        const string probe = """
+            DECLARE @edition sysname;
+            SET @edition = cast(SERVERPROPERTY(N'EDITION') as sysname);
+            SELECT case when @edition = N'SQL Azure' then 2 else 1 end as 'DatabaseEngineType', SERVERPROPERTY('EngineEdition') AS DatabaseEngineEdition, SERVERPROPERTY('ProductVersion') AS ProductVersion, @@MICROSOFTVERSION AS MicrosoftVersion, 0 as IsFabricServer, convert(sysname, SERVERPROPERTY(N'Collation')) AS Collation;
+            select host_platform from sys.dm_os_host_info
+            if @edition = N'SQL Azure'
+              select 'TCP' as ConnectionProtocol
+            else
+              exec ('select CONVERT(nvarchar(40),CONNECTIONPROPERTY(''net_transport'')) as ConnectionProtocol')
+            """;
+
+        await using var command = new SqlCommand(probe, connection);
+        await using var reader = await command.ExecuteReaderAsync(TestContext.CancellationToken);
+
+        var resultSets = 0;
+        var lastColumn = "";
+        do
+        {
+            var rows = 0;
+            while (await reader.ReadAsync(TestContext.CancellationToken))
+                rows++;
+            AreEqual(1, rows);
+            lastColumn = reader.GetName(reader.FieldCount - 1);
+            resultSets++;
+        }
+        while (await reader.NextResultAsync(TestContext.CancellationToken));
+
+        AreEqual(3, resultSets);
+        AreEqual("ConnectionProtocol", lastColumn);
+    }
+}

SqlServerSimulator.Tests.SqlClient/NetworkListenerTests.cs

@@ -37,18 +37,16 @@ public async Task ListenAsync_PortZero_AssignsEphemeralPort()
     }
 
     // SqlConnection.ServerVersion is parsed from the LOGINACK token's
-    // ProgVersion (major.minor.build). The simulator deliberately reports a
-    // 0 build ("17.00.0000") as an honest "not a real SQL Server build"
-    // marker — probed harmless to SMO's Object Explorer (the Databases node
-    // populates regardless; the enumeration gate was ntext RPC-param support,
-    // not the reported version).
+    // ProgVersion (major.minor.build). The simulator reports the SQL Server
+    // 2025 reference build 17.0.4065.4, so SqlClient reads "17.00.4065" — a
+    // real build number is what lets SSMS's per-build feature gates proceed.
     [TestMethod]
-    public async Task LoginAck_ReportsSimulatedZeroBuild()
+    public async Task LoginAck_ReportsReferenceBuild()
     {
         var simulation = new Simulation();
         await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
         await using var connection = new SqlConnection(ConnectionString(listener));
         await connection.OpenAsync(TestContext.CancellationToken);
-        AreEqual("17.00.0000", connection.ServerVersion);
+        AreEqual("17.00.4065", connection.ServerVersion);
     }
 }

SqlServerSimulator.Tests/AtAtKeywordExpansionTests.cs

@@ -23,7 +23,7 @@ public void AtAt_MaxConnections_Returns32767()
 
     [TestMethod]
     public void AtAt_MicrosoftVersion_ReturnsProductVersionEncoding()
-        => AreEqual(285212672, new Simulation().ExecuteScalar("select @@microsoftversion"));
+        => AreEqual(285216737, new Simulation().ExecuteScalar("select @@microsoftversion"));
 
     [TestMethod]
     public void AtAt_MicrosoftVersion_ComposesInExpression()

SqlServerSimulator.Tests/CollationDeclaredColumnTests.cs

@@ -421,6 +421,77 @@ public void TempTable_InheritsActiveDatabaseDefaultCollation()
         AreEqual(1, n);
     }
 
+    /// <summary>
+    /// <c>COLLATE database_default</c> in a table-variable column definition
+    /// resolves to the active database's collation at bind time. SSMS's Disk
+    /// Usage report declares <c>nvarchar(...) COLLATE database_default</c>
+    /// table variables; before this the keyword was rejected as an
+    /// unrecognized collation. Probe-confirmed against SQL Server 2025:
+    /// <c>SQL_VARIANT_PROPERTY(..., 'Collation')</c> reports the active
+    /// database's collation.
+    /// </summary>
+    [TestMethod]
+    public void TableVariable_CollateDatabaseDefault_ResolvesToActiveDatabaseCollation()
+    {
+        var sim = new Simulation();
+        using var conn = sim.CreateOpenConnection();
+        _ = conn.CreateCommand("alter database simulated collate Latin1_General_CS_AS").ExecuteNonQuery();
+        var coll = conn.CreateCommand(
+            "declare @tv table (c nvarchar(10) collate database_default); insert @tv values (N'a'); " +
+            "select convert(sysname, sql_variant_property(cast(c as sql_variant), 'Collation')) from @tv").ExecuteScalar();
+        AreEqual("Latin1_General_CS_AS", coll);
+    }
+
+    /// <summary>
+    /// <c>COLLATE database_default</c> on a <c>#temp</c> column resolves to the
+    /// *session* database's collation — probe-confirmed the real server uses
+    /// the connection's active database, not tempdb's, so the resolved value
+    /// matches an ordinary column's.
+    /// </summary>
+    [TestMethod]
+    public void TempTable_CollateDatabaseDefault_ResolvesToSessionDatabaseCollation()
+    {
+        var sim = new Simulation();
+        using var conn = sim.CreateOpenConnection();
+        _ = conn.CreateCommand("alter database simulated collate Latin1_General_CS_AS").ExecuteNonQuery();
+        _ = conn.CreateCommand("create table #t (c nvarchar(10) collate database_default); insert #t values (N'a')").ExecuteNonQuery();
+        var coll = conn.CreateCommand(
+            "select convert(sysname, sql_variant_property(cast(c as sql_variant), 'Collation')) from #t").ExecuteScalar();
+        AreEqual("Latin1_General_CS_AS", coll);
+    }
+
+    /// <summary>
+    /// <c>COLLATE database_default</c> in a regular <c>CREATE TABLE</c> column
+    /// records the resolved database collation in
+    /// <c>sys.columns.collation_name</c> (matching real), and the keyword is
+    /// case-insensitive.
+    /// </summary>
+    [TestMethod]
+    public void CreateTable_CollateDatabaseDefault_RecordsResolvedCollationCaseInsensitive()
+    {
+        var sim = new Simulation();
+        using var conn = sim.CreateOpenConnection();
+        _ = conn.CreateCommand("alter database simulated collate Latin1_General_CS_AS").ExecuteNonQuery();
+        _ = conn.CreateCommand("create table t (a nvarchar(10) collate DATABASE_DEFAULT)").ExecuteNonQuery();
+        AreEqual("Latin1_General_CS_AS", conn.CreateCommand(
+            "select collation_name from sys.columns where object_id = object_id('t') and name = 'a'").ExecuteScalar());
+    }
+
+    /// <summary>
+    /// Expression-level <c>expr COLLATE database_default</c> resolves to the
+    /// active database's collation (probe-confirmed), sharing the same
+    /// keyword-resolution seam as the column-definition sites.
+    /// </summary>
+    [TestMethod]
+    public void Expression_CollateDatabaseDefault_ResolvesToActiveDatabaseCollation()
+    {
+        var sim = new Simulation();
+        using var conn = sim.CreateOpenConnection();
+        _ = conn.CreateCommand("alter database simulated collate Latin1_General_CS_AS").ExecuteNonQuery();
+        AreEqual("Latin1_General_CS_AS", conn.CreateCommand(
+            "select convert(sysname, sql_variant_property(N'x' collate database_default, 'Collation'))").ExecuteScalar());
+    }
+
     /// <summary>
     /// LIKE consults the column's collation's <c>CaseSensitive</c> flag —
     /// covers the <c>CultureCollation.CaseSensitive</c> property path the

SqlServerSimulator.Tests/JoinTests.cs

@@ -407,7 +407,7 @@ select 1 from a right join (select id from b where b.ref_id = o.id) bx
     public void RightJoin_DerivedTableRight_LateralCorrelationToLeft_Rejected()
     {
         // Real SQL Server raises Msg 4104 ("multi-part identifier could not be bound")
-        // at bind-time; the simulator raises Msg 207 ("Invalid column name 'a.id'") at
+        // at bind-time; the simulator raises Msg 207 ("Invalid column name 'id'") at
         // runtime because Reference.Run is the resolution point — the derived-table
         // parse doesn't see the left-side snapshot resolver, so resolution falls through
         // to the (null at top-level) outer resolver and fails on the first inner row.
@@ -421,6 +421,19 @@ public void RightJoin_DerivedTableRight_LateralCorrelationToLeft_Rejected()
             """, 207);
     }
 
+    /// <summary>
+    /// Msg 207 renders only the leaf identifier — a qualified reference to a
+    /// nonexistent column drops the table / alias qualifier, matching real
+    /// SQL Server verbatim (probe-confirmed: <c>col.is_replicated</c> surfaces
+    /// as <c>"Invalid column name 'is_replicated'."</c>, not the qualified
+    /// form). Surfaced by SSMS's Table-Designer column query.
+    /// </summary>
+    [TestMethod]
+    public void InvalidColumnName_QualifiedReference_RendersLeafOnly()
+        => new Simulation().AssertSqlError(
+            "create table t (id int); select t.nosuchcol from t",
+            207, "Invalid column name 'nosuchcol'.");
+
     [TestMethod]
     public void CommaFrom_TwoSources_FilterEqualsInnerJoin()
     {