SchemaObject abstract base — unify the metadata of every named schema-resident database object behind one type. HeapTable / View / Procedure / Sequence / TableType / Trigger / UserDefinedFunction (and its ScalarFunction / InlineTableValuedFunction sealed derivees) all : SchemaObject(name, objectId, schemaId, createDate) now; their duplicated Name / ObjectId / CreateDate fields are gone. The base also stores ModifyDate (mutable, defaults to CreateDate so the ALTER-bumps-modify-date hook lands in one place) and exposes two abstract members — ObjectTypeCode (the 2-char sys.objects.type: 'U '/'V '/'P '/'FN'/'IF'/'TR'/'SO'/'TT') and ObjectTypeDescription ('USER_TABLE'/'VIEW'/etc.) — so catalog-view projection reads the discriminator directly off the instance rather than threading 18 precomputed SqlValues through helper methods. TableType.TypeTableObjectId folded into the inherited ObjectId (and that's now what sys.table_types.type_table_object_id projects). Trigger.Parent typed as SchemaObject (was object); the ParentObjectId runtime-switch property gone — call sites read trigger.Parent.ObjectId directly. DML hook parameters (Update / Delete / Drop / InvokeTrigger) retyped object→SchemaObject; the (object?)sourceView ?? table ternaries become (SchemaObject?)sourceView ?? table. New Schema.SchemaObjects() yields every object in the shared object-name namespace (HeapTables + Views + Functions + Procedures + Sequences + Triggers — TableTypes deliberately excluded since probe-confirmed those occupy a separate namespace), and Schema.HasNameInSharedNamespace(leaf) tightens the previously-inconsistent CREATE-time Msg 2714 check: CREATE TABLE was missing the cross-kind scan entirely; CREATE FUNCTION checked only 2 dicts; CREATE VIEW checked 3; CREATE PROCEDURE checked 3; CREATE SEQUENCE checked 4; CREATE TRIGGER checked 5. All six paths now call the same one-line predicate and reject every shared-namespace collision (matches real SQL Server's behavior — none of the existing tests broke since each one was already testing within its dict's scope). sys.objects iteration collapses from 5 manually-ordered kind groups with hand-coded type/typeDesc per yield to a single schema.SchemaObjects().OrderBy(o => o.ObjectId) loop reading obj.ObjectTypeCode / obj.ObjectTypeDescription directly; constraint rows (PK / UQ / CHECK) still emit immediately after their owning HeapTable so the natural ordering matches probe. EnumerateProcedures / EnumerateSysTriggers stay single-kind enumerators with hoisted type/typeDesc constants for per-row allocation savings. 3326 / 264 tests pass; dotnet format clean. No behavior change beyond the tightened CREATE-time collision check.

Author: RyanLamansky

SqlServerSimulator/BuiltInResources.cs

@@ -167,27 +167,21 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
                     notMsShipped,
                 }));
 
-        // sys.objects: a superset of sys.tables that also emits one row per
-        // PK / UQ / CHECK constraint, with parent_object_id linking back to
-        // the owning table. type_desc strings probe-confirmed: 'U ' /
-        // USER_TABLE, 'PK' / PRIMARY_KEY_CONSTRAINT, 'UQ' / UNIQUE_CONSTRAINT,
-        // 'C ' / CHECK_CONSTRAINT.
+        // sys.objects: every <see cref="SchemaObject"/> emits one row, plus
+        // one extra row per HeapTable PK / UQ / CHECK constraint linked via
+        // parent_object_id. type / type_desc come from the SchemaObject's
+        // own ObjectTypeCode / ObjectTypeDescription (probe-confirmed
+        // values: 'U ' / USER_TABLE, 'V ' / VIEW, 'P ' / SQL_STORED_PROCEDURE,
+        // 'FN' / SQL_SCALAR_FUNCTION, 'IF' / SQL_INLINE_TABLE_VALUED_FUNCTION,
+        // 'TR' / SQL_TRIGGER). Constraint codes ('PK', 'UQ', 'C ') live
+        // outside the SchemaObject contract since constraints aren't first-
+        // class schema objects.
         var pkType = SqlValue.FromChar(charTwo, "PK");
         var pkTypeDesc = SqlValue.FromNVarchar("PRIMARY_KEY_CONSTRAINT");
         var uqType = SqlValue.FromChar(charTwo, "UQ");
         var uqTypeDesc = SqlValue.FromNVarchar("UNIQUE_CONSTRAINT");
         var checkType = SqlValue.FromChar(charTwo, "C ");
         var checkTypeDesc = SqlValue.FromNVarchar("CHECK_CONSTRAINT");
-        var fnType = SqlValue.FromChar(charTwo, "FN");
-        var fnTypeDesc = SqlValue.FromNVarchar("SQL_SCALAR_FUNCTION");
-        var inlineTvfType = SqlValue.FromChar(charTwo, "IF");
-        var inlineTvfTypeDesc = SqlValue.FromNVarchar("SQL_INLINE_TABLE_VALUED_FUNCTION");
-        var viewType = SqlValue.FromChar(charTwo, "V ");
-        var viewTypeDesc = SqlValue.FromNVarchar("VIEW");
-        var procType = SqlValue.FromChar(charTwo, "P ");
-        var procTypeDesc = SqlValue.FromNVarchar("SQL_STORED_PROCEDURE");
-        var triggerType = SqlValue.FromChar(charTwo, "TR");
-        var triggerTypeDesc = SqlValue.FromNVarchar("SQL_TRIGGER");
         var zeroParent = SqlValue.FromInt32(0);
         var objectsColumns = new HeapColumn[]
         {
@@ -202,7 +196,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
             new("is_ms_shipped", SqlType.Bit, null, true),
         };
         var objectsView = new CatalogView("objects", objectsColumns, batch =>
-            EnumerateObjects(batch, tableType, tableTypeDesc, pkType, pkTypeDesc, uqType, uqTypeDesc, checkType, checkTypeDesc, fnType, fnTypeDesc, inlineTvfType, inlineTvfTypeDesc, viewType, viewTypeDesc, procType, procTypeDesc, triggerType, triggerTypeDesc, zeroParent, notMsShipped));
+            EnumerateObjects(batch, charTwo, pkType, pkTypeDesc, uqType, uqTypeDesc, checkType, checkTypeDesc, zeroParent, notMsShipped));
 
         // sys.columns: load-bearing subset of real SQL Server's column set.
         // Probe-confirmed (2026-05-11): max_length is byte-length (4 for int,
@@ -367,7 +361,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
             new("is_ms_shipped", SqlType.Bit, null, false),
         };
         var proceduresView = new CatalogView("procedures", proceduresColumns, batch =>
-            EnumerateProcedures(batch, procType, procTypeDesc, notMsShipped));
+            EnumerateProcedures(batch, charTwo, notMsShipped));
 
         // INFORMATION_SCHEMA.ROUTINES: ISO-shape view listing both procedures
         // and functions. The simulator ships the load-bearing column subset:
@@ -522,7 +516,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
             new("is_not_for_replication", SqlType.Bit, null, false),
         };
         var triggersView = new CatalogView("triggers", triggersColumns, batch =>
-            EnumerateSysTriggers(batch, parentClassObjectColumn, parentClassObjectColumnDesc, triggerType, triggerTypeDesc));
+            EnumerateSysTriggers(batch, charTwo, parentClassObjectColumn, parentClassObjectColumnDesc));
 
         // INFORMATION_SCHEMA.DOMAINS: ISO-standard surface. Real SQL Server
         // emits a row for every user-defined type (scalar UDTs surface their
@@ -624,7 +618,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysTableTypes(Parser.BatchContex
             {
                 yield return [
                     SqlValue.FromSystemName(tt.Name),
-                    SqlValue.FromInt32(tt.TypeTableObjectId),
+                    SqlValue.FromInt32(tt.ObjectId),
                     trueBit,
                     schemaId,
                     SqlValue.FromInt32(tt.UserTypeId),
@@ -651,13 +645,17 @@ private static IEnumerable<SqlValue[]> EnumerateSysTableTypes(Parser.BatchContex
     /// </summary>
     private static IEnumerable<SqlValue[]> EnumerateSysTriggers(
         Parser.BatchContext batch,
+        SqlType charTwo,
         SqlValue parentClassObjectColumn,
-        SqlValue parentClassObjectColumnDesc,
-        SqlValue triggerType,
-        SqlValue triggerTypeDesc)
+        SqlValue parentClassObjectColumnDesc)
     {
         var trueBit = SqlValue.FromBoolean(true);
         var falseBit = SqlValue.FromBoolean(false);
+        // 'TR' / 'SQL_TRIGGER' — matches Trigger.ObjectTypeCode /
+        // Trigger.ObjectTypeDescription, kept as local constants here to
+        // avoid one SqlValue allocation per row.
+        var triggerType = SqlValue.FromChar(charTwo, "TR");
+        var triggerTypeDesc = SqlValue.FromNVarchar("SQL_TRIGGER");
         foreach (var schema in batch.CurrentDatabase.Schemas.Values)
         {
             foreach (var trigger in schema.Triggers.Values.OrderBy(t => t.ObjectId))
@@ -668,7 +666,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysTriggers(
                     SqlValue.FromInt32(trigger.ObjectId),
                     parentClassObjectColumn,
                     parentClassObjectColumnDesc,
-                    SqlValue.FromInt32(trigger.ParentObjectId),
+                    SqlValue.FromInt32(trigger.Parent.ObjectId),
                     triggerType,
                     triggerTypeDesc,
                     createDate,
@@ -751,17 +749,21 @@ private static IEnumerable<SqlValue[]> EnumerateInformationSchemaDomains(Parser.
     /// Rows for <c>sys.procedures</c>: one row per <see cref="Procedure"/> in
     /// every schema. The full <c>create_date</c> / <c>modify_date</c> story
     /// in real SQL Server tracks ALTER PROCEDURE separately; the simulator
-    /// uses the ALTER-preserving <see cref="Procedure.CreateDate"/> for both
+    /// uses the ALTER-preserving <see cref="SchemaObject.CreateDate"/> for both
     /// columns (the original create date survives ALTER, matching the way
-    /// <see cref="Procedure.ObjectId"/> survives — minor fidelity gap on
+    /// <see cref="SchemaObject.ObjectId"/> survives — minor fidelity gap on
     /// modify_date which would shift on each ALTER in real SQL Server).
     /// </summary>
     private static IEnumerable<SqlValue[]> EnumerateProcedures(
         Parser.BatchContext batch,
-        SqlValue procType,
-        SqlValue procTypeDesc,
+        SqlType charTwo,
         SqlValue notMsShipped)
     {
+        // 'P ' / 'SQL_STORED_PROCEDURE' — matches Procedure.ObjectTypeCode /
+        // Procedure.ObjectTypeDescription, kept as local constants here to
+        // avoid one SqlValue allocation per row.
+        var procType = SqlValue.FromChar(charTwo, "P ");
+        var procTypeDesc = SqlValue.FromNVarchar("SQL_STORED_PROCEDURE");
         foreach (var schema in batch.CurrentDatabase.Schemas.Values)
         {
             foreach (var proc in schema.Procedures.Values.OrderBy(p => p.ObjectId))
@@ -1110,9 +1112,9 @@ private static IEnumerable<SqlValue[]> EnumerateColumns(
             // Table types surface their columns through sys.columns keyed by
             // type_table_object_id (probe G3). Computed columns inherit
             // is_computed=true; identity columns inherit is_identity=true.
-            foreach (var tt in schema.TableTypes.Values.OrderBy(t => t.TypeTableObjectId))
+            foreach (var tt in schema.TableTypes.Values.OrderBy(t => t.ObjectId))
             {
-                var typeObjectId = SqlValue.FromInt32(tt.TypeTableObjectId);
+                var typeObjectId = SqlValue.FromInt32(tt.ObjectId);
                 for (var i = 0; i < tt.Columns.Length; i++)
                 {
                     var col = tt.Columns[i];
@@ -1346,104 +1348,52 @@ private static (int? CharLength, int? OctetLength, byte? NumericPrecision, int?
 
     private static IEnumerable<SqlValue[]> EnumerateObjects(
         Parser.BatchContext batch,
-        SqlValue tableType, SqlValue tableTypeDesc,
+        SqlType charTwo,
         SqlValue pkType, SqlValue pkTypeDesc,
         SqlValue uqType, SqlValue uqTypeDesc,
         SqlValue checkType, SqlValue checkTypeDesc,
-        SqlValue fnType, SqlValue fnTypeDesc,
-        SqlValue inlineTvfType, SqlValue inlineTvfTypeDesc,
-        SqlValue viewType, SqlValue viewTypeDesc,
-        SqlValue procType, SqlValue procTypeDesc,
-        SqlValue triggerType, SqlValue triggerTypeDesc,
         SqlValue zeroParent, SqlValue notMsShipped)
     {
         foreach (var schema in batch.CurrentDatabase.Schemas.Values)
         {
-            foreach (var fn in schema.Functions.Values.OrderBy(f => f.ObjectId))
-            {
-                var (typeCode, typeDesc) = fn switch
-                {
-                    InlineTableValuedFunction => (inlineTvfType, inlineTvfTypeDesc),
-                    _ => (fnType, fnTypeDesc),
-                };
-                yield return [
-                    SqlValue.FromInt32(fn.ObjectId),
-                    SqlValue.FromSystemName(fn.Name),
-                    SqlValue.FromInt32(fn.Schema.SchemaId),
-                    zeroParent,
-                    typeCode,
-                    typeDesc,
-                    SqlValue.FromDateTime(fn.CreateDate),
-                    SqlValue.FromDateTime(fn.CreateDate),
-                    notMsShipped,
-                ];
-            }
-            foreach (var view in schema.Views.Values.OrderBy(v => v.ObjectId))
-            {
-                yield return [
-                    SqlValue.FromInt32(view.ObjectId),
-                    SqlValue.FromSystemName(view.Name),
-                    SqlValue.FromInt32(view.Schema.SchemaId),
-                    zeroParent,
-                    viewType,
-                    viewTypeDesc,
-                    SqlValue.FromDateTime(view.CreateDate),
-                    SqlValue.FromDateTime(view.CreateDate),
-                    notMsShipped,
-                ];
-            }
-            foreach (var proc in schema.Procedures.Values.OrderBy(p => p.ObjectId))
-            {
-                yield return [
-                    SqlValue.FromInt32(proc.ObjectId),
-                    SqlValue.FromSystemName(proc.Name),
-                    SqlValue.FromInt32(proc.Schema.SchemaId),
-                    zeroParent,
-                    procType,
-                    procTypeDesc,
-                    SqlValue.FromDateTime(proc.CreateDate),
-                    SqlValue.FromDateTime(proc.CreateDate),
-                    notMsShipped,
-                ];
-            }
-            foreach (var trigger in schema.Triggers.Values.OrderBy(t => t.ObjectId))
+            // Schema-resident objects in ObjectId order. SchemaObject's
+            // ObjectTypeCode / ObjectTypeDescription supply the discriminators,
+            // so adding a new schema-object kind (e.g. surfacing Sequences /
+            // TableTypes in sys.objects later) only requires implementing the
+            // two abstract members on that type.
+            foreach (var obj in schema.SchemaObjects().OrderBy(o => o.ObjectId))
             {
+                var parent = obj is Trigger trigger
+                    ? SqlValue.FromInt32(trigger.Parent.ObjectId)
+                    : zeroParent;
                 yield return [
-                    SqlValue.FromInt32(trigger.ObjectId),
-                    SqlValue.FromSystemName(trigger.Name),
-                    SqlValue.FromInt32(trigger.Schema.SchemaId),
-                    SqlValue.FromInt32(trigger.ParentObjectId),
-                    triggerType,
-                    triggerTypeDesc,
-                    SqlValue.FromDateTime(trigger.CreateDate),
-                    SqlValue.FromDateTime(trigger.CreateDate),
+                    SqlValue.FromInt32(obj.ObjectId),
+                    SqlValue.FromSystemName(obj.Name),
+                    SqlValue.FromInt32(obj.SchemaId),
+                    parent,
+                    SqlValue.FromChar(charTwo, obj.ObjectTypeCode),
+                    SqlValue.FromNVarchar(obj.ObjectTypeDescription),
+                    SqlValue.FromDateTime(obj.CreateDate),
+                    SqlValue.FromDateTime(obj.ModifyDate),
                     notMsShipped,
                 ];
-            }
-            foreach (var t in schema.HeapTables.Values.OrderBy(t => t.ObjectId))
-            {
-                var schemaId = SqlValue.FromInt32(t.SchemaId);
+
+                // Constraint rows hang off HeapTable parents — emit them
+                // immediately after the table they belong to so the natural
+                // sys.objects ordering matches probe-confirmed real-server
+                // shape (table rows interleaved with their own constraints).
+                if (obj is not HeapTable t) continue;
+                var schemaIdValue = SqlValue.FromInt32(t.SchemaId);
                 var createDate = SqlValue.FromDateTime(t.CreateDate);
                 var modifyDate = SqlValue.FromDateTime(t.ModifyDate);
-                yield return [
-                    SqlValue.FromInt32(t.ObjectId),
-                    SqlValue.FromSystemName(t.Name),
-                    schemaId,
-                    zeroParent,
-                    tableType,
-                    tableTypeDesc,
-                    createDate,
-                    modifyDate,
-                    notMsShipped,
-                ];
-                var parent = SqlValue.FromInt32(t.ObjectId);
+                var tableObjectId = SqlValue.FromInt32(t.ObjectId);
                 foreach (var key in t.KeyConstraints)
                 {
                     yield return [
                         SqlValue.FromInt32(key.ObjectId),
                         SqlValue.FromSystemName(key.Name),
-                        schemaId,
-                        parent,
+                        schemaIdValue,
+                        tableObjectId,
                         key.Kind == KeyConstraintKind.PrimaryKey ? pkType : uqType,
                         key.Kind == KeyConstraintKind.PrimaryKey ? pkTypeDesc : uqTypeDesc,
                         createDate,
@@ -1456,8 +1406,8 @@ private static IEnumerable<SqlValue[]> EnumerateObjects(
                     yield return [
                         SqlValue.FromInt32(chk.ObjectId),
                         SqlValue.FromSystemName(chk.Name),
-                        schemaId,
-                        parent,
+                        schemaIdValue,
+                        tableObjectId,
                         checkType,
                         checkTypeDesc,
                         createDate,

SqlServerSimulator/Parser/FromSource.cs

@@ -49,7 +49,7 @@ internal sealed class FromSource(
     /// Back-reference to the <see cref="HeapTable"/> when this source is a
     /// table (or system table); null for derived-table sources. Used by the
     /// UPDATE / DELETE mutation paths to reach the table's
-    /// <see cref="HeapTable.KeyConstraints"/> / <see cref="HeapTable.Name"/>
+    /// <see cref="HeapTable.KeyConstraints"/> / <see cref="SchemaObject.Name"/>
     /// after FROM parsing has identified which source is the mutation target.
     /// </summary>
     public readonly HeapTable? BackingTable = backingTable;

SqlServerSimulator/Procedure.cs

@@ -37,21 +37,12 @@ internal sealed class Procedure(
     ProcedureParameter[] parameters,
     string bodyText,
     DateTime createDate)
+    : SchemaObject(name, objectId, schema.SchemaId, createDate)
 {
     public readonly Schema Schema = schema;
-    public readonly string Name = name;
 
-    /// <summary>
-    /// Stable per-database identifier; preserved across <c>ALTER PROCEDURE</c>
-    /// (probe-confirmed: real SQL Server's ALTER keeps the same object_id, so
-    /// foreign refs in <c>sys.objects</c> stay consistent). Allocated at
-    /// CREATE PROCEDURE time from <see cref="Database.AllocateObjectId"/>;
-    /// stored mutable-by-ALTER on the procedure record. Replaced wholesale on
-    /// each ALTER because parameter list / body text both swap; the field is
-    /// readonly because the ALTER path constructs a fresh <see cref="Procedure"/>
-    /// instance carrying the preserved id.
-    /// </summary>
-    public readonly int ObjectId = objectId;
+    public override string ObjectTypeCode => "P ";
+    public override string ObjectTypeDescription => "SQL_STORED_PROCEDURE";
 
     /// <summary>
     /// Declared parameters in source order. Each carries name, type, optional
@@ -70,8 +61,6 @@ internal sealed class Procedure(
     /// invoked).
     /// </summary>
     public readonly string BodyText = bodyText;
-
-    public readonly DateTime CreateDate = createDate;
 }
 
 /// <summary>

SqlServerSimulator/Schema.cs

@@ -54,7 +54,7 @@ internal sealed class Schema(string name, int schemaId)
     /// resolves through this dict. Procedures share the object-name
     /// namespace with tables / views / functions (Msg 2714 on collision).
     /// <c>ALTER PROCEDURE</c> replaces the entry while preserving the
-    /// existing <see cref="Procedure.ObjectId"/>; <c>DROP PROCEDURE</c>
+    /// existing <see cref="SchemaObject.ObjectId"/>; <c>DROP PROCEDURE</c>
     /// removes it.
     /// </summary>
     public readonly ConcurrentDictionary<string, Procedure> Procedures = new(Collation.Default);
@@ -91,4 +91,39 @@ internal sealed class Schema(string name, int schemaId)
     /// of truth (ENABLE / DISABLE / DROP all operate on it).
     /// </summary>
     public readonly ConcurrentDictionary<string, Trigger> Triggers = new(Collation.Default);
+
+    /// <summary>
+    /// Yields every <see cref="SchemaObject"/> in this schema's
+    /// object-name namespace (heap tables, views, UDFs, procedures,
+    /// sequences, triggers) — the set whose leaf names must be unique
+    /// (Msg 2714 on CREATE collision). <see cref="TableTypes"/> are
+    /// deliberately omitted: probe-confirmed that table-type names occupy
+    /// a separate namespace from this set. Used by sys.objects projection
+    /// and by the CREATE-time auto-name-collision check.
+    /// </summary>
+    public IEnumerable<SchemaObject> SchemaObjects()
+    {
+        foreach (var t in this.HeapTables.Values) yield return t;
+        foreach (var v in this.Views.Values) yield return v;
+        foreach (var fn in this.Functions.Values) yield return fn;
+        foreach (var p in this.Procedures.Values) yield return p;
+        foreach (var s in this.Sequences.Values) yield return s;
+        foreach (var tr in this.Triggers.Values) yield return tr;
+    }
+
+    /// <summary>
+    /// True when <paramref name="leaf"/> matches any existing name in
+    /// this schema's object-name namespace (<see cref="SchemaObjects"/>).
+    /// Used by every CREATE path to raise Msg 2714 before allocating an
+    /// ObjectId or writing into the relevant dict.
+    /// </summary>
+    public bool HasNameInSharedNamespace(string leaf)
+    {
+        foreach (var obj in this.SchemaObjects())
+        {
+            if (Collation.Default.Equals(obj.Name, leaf))
+                return true;
+        }
+        return false;
+    }
 }