Implemented sys.all_columns, sys.data_spaces, the six sys.tables table-flavor flags (is_memory_optimized / is_filetable / is_external / is_node / is_edge / ledger_type, accepted-but-constant since none of those table kinds are modeled), and a QUOTENAME fidelity fix.

Author: RyanLamansky

SqlServerSimulator.Tests/SsmsTablesNodeCatalogTests.cs

@@ -0,0 +1,149 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for the catalog surface SSMS Object Explorer's Tables node reads via
+/// SMO: <c>sys.all_columns</c> (user-object parity with <c>sys.columns</c> plus
+/// <c>is_sparse</c>), <c>sys.data_spaces</c> (single PRIMARY filegroup), the
+/// table-flavor flags on <c>sys.tables</c> (<c>is_memory_optimized</c> /
+/// <c>is_filetable</c> / <c>is_external</c> / <c>is_node</c> / <c>is_edge</c> /
+/// <c>ledger_type</c>), and the QUOTENAME collation-propagation fix the Urn
+/// concatenation exposed. Closes with a trimmed representative of SMO's Tables
+/// node query. Shapes/values probed against SQL Server 2025 (2026-07-15).
+/// </summary>
+[TestClass]
+public sealed class SsmsTablesNodeCatalogTests
+{
+    [TestMethod]
+    public void AllColumns_ExposesIsSparse_ForUserColumn()
+        => AreEqual(0, new Simulation().ExecuteScalar<int>("""
+            create table t (id int not null primary key, x int null);
+            select cast(is_sparse as int) from sys.all_columns
+            where object_id = object_id('t') and name = 'x'
+            """));
+
+    [TestMethod]
+    public void AllColumns_MatchesColumnsRowSet_ForUserTable()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (a int not null primary key, b nvarchar(20) null, c decimal(10, 2) null)");
+        AreEqual(
+            sim.ExecuteScalar<int>("select count(*) from sys.columns where object_id = object_id('t')"),
+            sim.ExecuteScalar<int>("select count(*) from sys.all_columns where object_id = object_id('t')"));
+    }
+
+    [TestMethod]
+    public void DataSpaces_ReturnsPrimaryFilegroup()
+    {
+        using var reader = new Simulation().ExecuteReader(
+            "select name, data_space_id, type, type_desc, is_default, is_system from sys.data_spaces");
+
+        IsTrue(reader.Read());
+        AreEqual("PRIMARY", reader.GetString(0));
+        AreEqual(1, reader.GetInt32(1));
+        AreEqual("FG", reader.GetString(2).TrimEnd());
+        AreEqual("ROWS_FILEGROUP", reader.GetString(3));
+        IsTrue(reader.GetBoolean(4));
+        IsFalse(reader.GetBoolean(5));
+        IsFalse(reader.Read());
+    }
+
+    /// <summary>
+    /// SMO's IsPartitioned probe joins sys.indexes.data_space_id to
+    /// sys.data_spaces and compares type to 'PS'. The single modeled row is a
+    /// row-filegroup ('FG'), so a PK's index always resolves to a non-partition
+    /// data space.
+    /// </summary>
+    [TestMethod]
+    public void DataSpaces_JoinFromIndex_ResolvesToFilegroupNotPartitionScheme()
+        => AreEqual(0, new Simulation().ExecuteScalar<int>("""
+            create table t (id int not null primary key);
+            select cast(case when 'PS' = dsidx.type then 1 else 0 end as int)
+            from sys.tables tbl
+            inner join sys.indexes idx on idx.object_id = tbl.object_id and idx.index_id < 2
+            left outer join sys.data_spaces dsidx on dsidx.data_space_id = idx.data_space_id
+            where tbl.object_id = object_id('t')
+            """));
+
+    [TestMethod]
+    public void Tables_TableFlavorFlags_AllZeroForUserTable()
+    {
+        using var reader = new Simulation().ExecuteReader("""
+            create table t (id int not null primary key);
+            select cast(is_memory_optimized as int), is_filetable, is_external, is_node, is_edge, ledger_type
+            from sys.tables where object_id = object_id('t')
+            """);
+
+        IsTrue(reader.Read());
+        AreEqual(0, reader.GetInt32(0));
+        IsFalse(reader.GetBoolean(1));
+        IsFalse(reader.GetBoolean(2));
+        IsFalse(reader.GetBoolean(3));
+        IsFalse(reader.GetBoolean(4));
+        AreEqual((byte)0, reader.GetByte(5));
+        IsFalse(reader.Read());
+    }
+
+    /// <summary>
+    /// Regression for the QUOTENAME collation fix. Under a non-baseline
+    /// database collation a plain string literal carries the database collation
+    /// while the sysname catalog column carries the baseline; before the fix
+    /// QUOTENAME dropped the input's Implicit coercibility and the Urn's
+    /// literal + QUOTENAME(...) concatenation raised Msg 468.
+    /// </summary>
+    [TestMethod]
+    public void QuoteName_UnderNonBaselineCollation_ConcatWithLiteralSucceeds()
+    {
+        var sim = new Simulation { ServerCollationName = "Latin1_General_100_CI_AS" };
+        _ = sim.ExecuteNonQuery("create table t (id int not null primary key)");
+        AreEqual("x[t]", sim.ExecuteScalar("select 'x' + quotename(name) from sys.tables where name = 't'"));
+    }
+
+    /// <summary>
+    /// Trimmed representative of SMO's Tables node query: the correlated
+    /// nonclustered-index probe, the is_ms_shipped + extended-property CASE
+    /// filter, and the sys.all_columns → sys.types join for XML detection. A
+    /// table with a clustered PK, a nonclustered index, and an xml column
+    /// projects HasClusteredIndex / HasPrimaryClusteredIndex / HasNonClustered /
+    /// HasXmlData = 1 and passes the exclusion filter.
+    /// </summary>
+    [TestMethod]
+    public void SmoTablesNodeShape_ProjectsExpectedFlags()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, payload xml null, note nvarchar(50) null);
+            create index ix_note on t (note);
+            """);
+
+        using var reader = sim.ExecuteReader("""
+            select
+                tbl.name,
+                cast(case idx.index_id when 1 then 1 else 0 end as int) as HasClusteredIndex,
+                cast(case idx.index_id when 1 then case when (idx.is_primary_key + 2 * idx.is_unique_constraint = 1) then 1 else 0 end else 0 end as int) as HasPrimaryClusteredIndex,
+                cast(isnull((select top 1 1 from sys.indexes ind where ind.object_id = tbl.object_id and ind.type > 1 and ind.is_hypothetical = 0), 0) as int) as HasNonClusteredIndex,
+                cast(isnull((select top 1 1 from sys.all_columns clmns join sys.types usrt on usrt.user_type_id = clmns.user_type_id where clmns.object_id = tbl.object_id and usrt.name = N'xml'), 0) as int) as HasXmlData,
+                cast(isnull((select distinct 1 from sys.all_columns where object_id = tbl.object_id and is_sparse = 1), 0) as int) as HasSparse
+            from sys.tables tbl
+            inner join sys.indexes idx on idx.object_id = tbl.object_id and idx.index_id < 2
+            where tbl.object_id = object_id('t')
+              and (cast(case
+                    when tbl.is_ms_shipped = 1 then 1
+                    when exists (select 1 from sys.extended_properties
+                        where major_id = tbl.object_id and minor_id = 0 and class = 1
+                          and name = N'microsoft_database_tools_support') then 1
+                    else 0 end as bit) = 0
+                   and tbl.is_filetable = 0 and tbl.temporal_type = 0 and cast(tbl.is_node as bit) = 0)
+            """);
+
+        IsTrue(reader.Read());
+        AreEqual("t", reader.GetString(0));
+        AreEqual(1, reader.GetInt32(1));
+        AreEqual(1, reader.GetInt32(2));
+        AreEqual(1, reader.GetInt32(3));
+        AreEqual(1, reader.GetInt32(4));
+        AreEqual(0, reader.GetInt32(5));
+        IsFalse(reader.Read());
+    }
+}

SqlServerSimulator/BuiltInResources.cs

@@ -171,6 +171,8 @@ void Iso(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
         var temporalDescNone = SqlValue.FromNVarchar("NON_TEMPORAL_TABLE");
         var temporalDescHistory = SqlValue.FromNVarchar("HISTORY_TABLE");
         var temporalDescBase = SqlValue.FromNVarchar("SYSTEM_VERSIONED_TEMPORAL_TABLE");
+        var falseTableFlag = SqlValue.FromBoolean(false);
+        var ledgerTypeNone = SqlValue.FromByte(0);
         Sys("tables",
         [
             new("object_id", SqlType.Int32, null, false),
@@ -184,6 +186,17 @@ void Iso(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
             new("temporal_type", SqlType.TinyInt, null, true),
             new("temporal_type_desc", nvarchar60Catalog, 60, true),
             new("history_table_id", SqlType.Int32, null, true),
+            // Table-flavor flags SMO's Object-Explorer Tables node filters on.
+            // None of these table kinds are modeled (memory-optimized,
+            // filetable, external/PolyBase, graph node/edge, ledger), so each
+            // ships as a constant 0. ledger_type is tinyint (0 = NON_LEDGER_TABLE,
+            // probe-confirmed non-null on SQL Server 2025). See docs/claude/catalog-views.md.
+            new("is_memory_optimized", SqlType.Bit, null, false),
+            new("is_filetable", SqlType.Bit, null, false),
+            new("is_external", SqlType.Bit, null, false),
+            new("is_node", SqlType.Bit, null, false),
+            new("is_edge", SqlType.Bit, null, false),
+            new("ledger_type", SqlType.TinyInt, null, false),
         ], (batch, database) =>
             database.Schemas.Values
                 .SelectMany(s => s.HeapTables.Values)
@@ -209,6 +222,12 @@ void Iso(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
                         tt,
                         ttd,
                         htid,
+                        falseTableFlag,
+                        falseTableFlag,
+                        falseTableFlag,
+                        falseTableFlag,
+                        falseTableFlag,
+                        ledgerTypeNone,
                     };
                 }));
 
@@ -252,7 +271,14 @@ void Iso(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
         var systemTypeId = SqlType.TinyInt;
         var defaultCollation = SqlValue.FromSystemName("SQL_Latin1_General_CP1_CI_AS");
         var nullCollation = SqlValue.Null(SqlType.SystemName);
-        Sys("columns",
+        // sys.columns / sys.all_columns share one shape. is_sparse ships as a
+        // constant 0 (the simulator has no sparse-column storage); SMO's
+        // Object-Explorer HasSparseColumn probe reads it off sys.all_columns.
+        // sys.all_columns is user-object-parity with sys.columns here: real
+        // SQL Server also surfaces system objects' negative-object_id columns,
+        // but SMO correlates only on user tables' object_ids so the identical
+        // user-column row set suffices. See docs/claude/catalog-views.md.
+        HeapColumn[] ColumnsShape() =>
         [
             new("object_id", SqlType.Int32, null, false),
             new("name", SqlType.SystemName, 128, false),
@@ -266,8 +292,12 @@ void Iso(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
             new("is_identity", SqlType.Bit, null, false),
             new("is_computed", SqlType.Bit, null, false),
             new("collation_name", SqlType.SystemName, 128, true),
-        ], (batch, database) =>
-            EnumerateColumns(batch, database, defaultCollation, nullCollation));
+            new("is_sparse", SqlType.Bit, null, true),
+        ];
+        IEnumerable<SqlValue[]> ColumnRows(Parser.BatchContext batch, Database database) =>
+            EnumerateColumns(batch, database, defaultCollation, nullCollation);
+        Sys("columns", ColumnsShape(), ColumnRows);
+        Sys("all_columns", ColumnsShape(), ColumnRows);
 
         // sys.sql_modules: one row per programmable module (procedure / view /
         // DML + DDL trigger / scalar / inline / multi-statement function),
@@ -738,6 +768,40 @@ void Iso(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
             new("statistics_incremental", SqlType.Bit, null, true),
         ], EnumerateSysIndexes);
 
+        // sys.data_spaces: the simulator models a single PRIMARY row-filegroup
+        // (data_space_id = 1) — the same id every sys.indexes row reports for
+        // data_space_id, so SMO's LEFT JOIN idx.data_space_id → dsidx resolves.
+        // Probe-confirmed shape (SQL Server 2025): name / data_space_id / type
+        // char(2) / type_desc / is_default / is_system. 'FG' = ROWS_FILEGROUP;
+        // partition schemes ('PS' — what SMO's IsPartitioned probe compares
+        // against) aren't modeled, so type is always 'FG'. See
+        // docs/claude/catalog-views.md.
+        var filegroupType = SqlValue.FromChar(charTwo, "FG");
+        var filegroupTypeDesc = SqlValue.FromNVarchar("ROWS_FILEGROUP");
+        Sys("data_spaces",
+        [
+            new("name", SqlType.SystemName, 128, false),
+            new("data_space_id", SqlType.Int32, null, false),
+            new("type", charTwo, 2, false),
+            new("type_desc", nvarchar60Catalog, 60, true),
+            new("is_default", SqlType.Bit, null, true),
+            new("is_system", SqlType.Bit, null, true),
+        ], (batch, database) =>
+        {
+            _ = (batch, database);
+            return
+            [
+                [
+                    SqlValue.FromSystemName("PRIMARY"),
+                    SqlValue.FromInt32(1),
+                    filegroupType,
+                    filegroupTypeDesc,
+                    SqlValue.FromBoolean(true),
+                    SqlValue.FromBoolean(false),
+                ],
+            ];
+        });
+
         // sys.index_columns: probe-confirmed 10-column shape. One row per
         // (index, column) pair — KEY columns get key_ordinal = 1..N and
         // index_column_id = 1..N; INCLUDE columns get key_ordinal = 0 and
@@ -3892,6 +3956,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         SqlValue.FromBoolean(col.Identity is not null),
                         SqlValue.FromBoolean(col.Computed is not null),
                         CollationFor(col),
+                        falseBit,
                     ];
                 }
             }
@@ -3918,6 +3983,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         falseBit,
                         falseBit,
                         CollationFor(col),
+                        falseBit,
                     ];
                 }
             }
@@ -3944,6 +4010,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         falseBit,
                         falseBit,
                         CollationFor(col),
+                        falseBit,
                     ];
                 }
             }
@@ -3970,6 +4037,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         SqlValue.FromBoolean(col.Identity is not null),
                         SqlValue.FromBoolean(col.Computed is not null),
                         CollationFor(col),
+                        falseBit,
                     ];
                 }
             }

SqlServerSimulator/Parser/Expressions/QuoteName.cs

@@ -36,8 +36,15 @@ public QuoteName(ParserContext context)
     public override SqlValue Run(RuntimeContext runtime)
     {
         var nameValue = this.name.Run(runtime);
+        // The result carries the input argument's collation and coercibility
+        // (real SQL Server propagates the operand's collation through string
+        // functions). Pinning to the neutral SqlType.NVarchar instead would
+        // give a coercible-default Baseline value that collides with a
+        // database-default-collation literal under Msg 468 when the two are
+        // concatenated (SMO's Urn: 'text' + QUOTENAME(sys-catalog sysname)).
+        var resultType = ResultType(nameValue.Type);
         if (nameValue.IsNull)
-            return SqlValue.Null(SqlType.NVarchar);
+            return SqlValue.Null(resultType);
 
         char open, close;
         if (this.delimiter is null)
@@ -48,34 +55,44 @@ public override SqlValue Run(RuntimeContext runtime)
         {
             var delimValue = this.delimiter.Run(runtime);
             if (delimValue.IsNull)
-                return SqlValue.Null(SqlType.NVarchar);
+                return SqlValue.Null(resultType);
 
             // Multi-char delimiter argument: SQL Server picks the first character
             // (probe-confirmed: '<<' selects '<' which pairs with '>').
             var delimString = SqlType.IsStringCategory(delimValue.Type)
                 ? delimValue.AsString
                 : delimValue.CoerceTo(SqlType.NVarchar).AsString;
             if (delimString.Length == 0)
-                return SqlValue.Null(SqlType.NVarchar);
+                return SqlValue.Null(resultType);
 
             if (!TryResolveDelimiterPair(delimString[0], out open, out close))
-                return SqlValue.Null(SqlType.NVarchar);
+                return SqlValue.Null(resultType);
         }
 
         var nameString = nameValue.AsString;
         if (nameString.Length > MaxInputLength)
-            return SqlValue.Null(SqlType.NVarchar);
+            return SqlValue.Null(resultType);
 
         // Closing-character doubling: only matters when open != close; when
         // they're identical (e.g. " or '), the same character gets doubled
         // anyway, so the same code path is correct without branching.
         var doubled = nameString.Contains(close, StringComparison.Ordinal)
             ? nameString.Replace(close.ToString(), $"{close}{close}", StringComparison.Ordinal)
             : nameString;
-        return SqlValue.FromNVarchar($"{open}{doubled}{close}");
+        return SqlValue.FromNVarchar(resultType, $"{open}{doubled}{close}");
     }
 
-    public override SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType) => SqlType.NVarchar;
+    public override SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType) =>
+        ResultType(this.name.GetSqlType(batch, resolveColumnType));
+
+    /// <summary>
+    /// <c>nvarchar(258)</c> carrying the input argument's collation and
+    /// coercibility (Baseline / coercible-default for non-string inputs).
+    /// </summary>
+    private static NVarcharSqlType ResultType(SqlType inputType) =>
+        NVarcharSqlType.Get(ResultLength, inputType.Collation ?? Collation.Baseline, inputType.Coercibility);
+
+    private const int ResultLength = 258;
 
     /// <summary>
     /// Maps the user-supplied delimiter character to the <c>(open, close)</c>