SCHEMA_NAME / OBJECT_NAME / OBJECT_SCHEMA_NAME scalars — the int→name inverses of SCHEMA_ID / OBJECT_ID, paired with a CLAUDE.md cleanup of a misleading "Not modeled" entry. SCHEMA_NAME([id]) walks Database.Schemas.Values by SchemaId; no-arg form returns Database.DefaultSchemaName ("dbo") matching real SQL Server's "default schema for current user" semantic (single-principal simulator); NULL / missing / negative id → NULL; result sysname (nvarchar(128)). OBJECT_NAME(object_id [, database_id]) walks every Schema.SchemaObjects() (heap tables / views / functions / procedures / sequences / triggers — the shared object namespace) plus Schema.TableTypes for the matching ObjectId; returns the object's leaf Name. OBJECT_SCHEMA_NAME(object_id [, database_id]) is the same lookup walk projecting the owning Schema.Name instead. Both optional database_id args are parsed-and-ignored (single-database simulator; real SQL Server uses the arg to scope across attached DBs). All three functions dispatch through Expression.ResolveBuiltIn's name-length switch: SCHEMA_NAME / OBJECT_NAME in the 11-char bucket, OBJECT_SCHEMA_NAME in the 18-char bucket. 20 new SchemaNameTests cover SCHEMA_NAME against the three built-in schemas (dbo / sys / INFORMATION_SCHEMA), user-schema round-trip through SCHEMA_ID, no-arg / NULL / missing / negative; OBJECT_NAME against tables / views / table-types (via type_table_object_id from sys.table_types since sys.objects doesn't yet surface TT-rows); OBJECT_SCHEMA_NAME against default-schema and named-schema tables; both with the ignored db_id arg form. Bonus cleanup: removed "Row-constructor IN ((1,2), (3,4))" from CLAUDE.md "Not modeled" — probe-confirmed real SQL Server 2025 rejects that syntax with Msg 4145 ("An expression of non-boolean type … near ','."), and the simulator already raises the same Msg with identical wording (it was never a missing feature, just a misleading doc entry). New RowConstructorIn_RejectedWithMatchingMsg4145 test pins the rejection wording. docs/claude/schemas.md gains an "Id → name scalars" section documenting all three functions plus the sys.objects-doesn't-surface-TableTypes gap (OBJECT_NAME / OBJECT_SCHEMA_NAME resolve TableTypes internally via Schema.TableTypes, so sys.table_types lookup works; sys.objects WHERE type = 'TT' returns empty — orthogonal BuiltInResources change).

RyanLamansky · RyanLamansky · commit 5fda360fd3b9 · 2026-05-13T08:27:55.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -157,7 +157,6 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - `RIGHT JOIN` / `FULL OUTER JOIN` with a derived-table or lateral right side — base tables / views / system tables on the right ship (see JOINs / APPLY); a derived-table right (always-deferred in this simulator) raises `NotSupportedException` since real SQL Server's Msg 4104 rejection of correlated subqueries on the right of RIGHT/FULL can't be statically distinguished from non-correlated ones.
 - Comma-separated FROM (legacy ANSI-89 join syntax).
 - `ANY` / `SOME` / `ALL` quantifiers.
-- Row-constructor `IN ((1,2), (3,4))`.
 - `RANGE BETWEEN <N> PRECEDING` / `<N> FOLLOWING` — real SQL Server gates the numeric-offset RANGE form behind a separately-licensed feature surface and the simulator matches that rejection (Msg 4194). `ROWS` numeric-offset frames ship; both modes support the canonical `UNBOUNDED` / `CURRENT ROW` bounds and the single-bound shorthand (`ROWS UNBOUNDED PRECEDING` ≡ `ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`). The default frame when ORDER BY is present in OVER is `RANGE UNBOUNDED PRECEDING TO CURRENT ROW` (running-total semantic with peer-tie grouping); without ORDER BY, default frame is whole partition. LAST_VALUE ships with the same semantics as real SQL Server (its default frame returns the current row's value or the peer-tie last under RANGE — the intuitive "partition last" form needs explicit `ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING`).
 - Recursive-part feature restrictions (Msg 460 DISTINCT / 461 TOP / 462 OUTER JOIN / 467 aggregate-or-GROUP-BY / 465 ref-in-subquery) — silently accepted with possibly-incorrect semantics rather than raising. Apps that exercise these in real SQL Server hit rejection there too.
 - `LIKE` with `COLLATE` override (default collation only).
diff --git a/SqlServerSimulator.Tests/SchemaNameTests.cs b/SqlServerSimulator.Tests/SchemaNameTests.cs
@@ -0,0 +1,100 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for the <c>SCHEMA_NAME([id])</c>, <c>OBJECT_NAME(object_id [, db_id])</c>,
+/// and <c>OBJECT_SCHEMA_NAME(object_id [, db_id])</c> scalar functions — the
+/// id-to-name inverses of <c>SCHEMA_ID</c> / <c>OBJECT_ID</c>. Probed against
+/// SQL Server 2025 (2026-05-13): result type is <c>sysname</c>; NULL argument
+/// or unknown id returns NULL; <c>SCHEMA_NAME()</c> no-arg form returns the
+/// caller's default schema (<c>dbo</c>); the optional <c>database_id</c>
+/// argument on <c>OBJECT_*</c> is accepted-and-ignored (single-database
+/// simulator).
+/// </summary>
+[TestClass]
+public sealed class SchemaNameTests
+{
+    [TestMethod]
+    public void SchemaName_Dbo_ReturnsDbo()
+        => AreEqual("dbo", new Simulation().ExecuteScalar("select schema_name(1)"));
+
+    [TestMethod]
+    public void SchemaName_Sys_ReturnsSys()
+        => AreEqual("sys", new Simulation().ExecuteScalar("select schema_name(4)"));
+
+    [TestMethod]
+    public void SchemaName_InformationSchema_ReturnsInformationSchema()
+        => AreEqual("INFORMATION_SCHEMA", new Simulation().ExecuteScalar("select schema_name(3)"));
+
+    [TestMethod]
+    public void SchemaName_UserSchema_RoundTripsThroughSchemaId()
+        => AreEqual("audit", new Simulation().ExecuteScalar("create schema audit; select schema_name(schema_id('audit'))"));
+
+    [TestMethod]
+    public void SchemaName_NoArg_ReturnsDbo()
+        => AreEqual("dbo", new Simulation().ExecuteScalar("select schema_name()"));
+
+    [TestMethod]
+    public void SchemaName_NullArg_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select schema_name(NULL)"));
+
+    [TestMethod]
+    public void SchemaName_MissingId_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select schema_name(99999)"));
+
+    [TestMethod]
+    public void SchemaName_NegativeId_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select schema_name(-1)"));
+
+    [TestMethod]
+    public void ObjectName_ExistingTable_ReturnsLeafName()
+        => AreEqual("foo", new Simulation().ExecuteScalar("create table foo (id int); select object_name(object_id('foo'))"));
+
+    [TestMethod]
+    public void ObjectName_NullArg_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select object_name(NULL)"));
+
+    [TestMethod]
+    public void ObjectName_MissingId_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select object_name(99999)"));
+
+    [TestMethod]
+    public void ObjectName_WithDbIdArg_IgnoresArg()
+        => AreEqual("foo", new Simulation().ExecuteScalar("create table foo (id int); select object_name(object_id('foo'), 1)"));
+
+    [TestMethod]
+    public void ObjectName_View_Works()
+        => AreEqual("v", new Simulation().ExecuteScalar("create table t (id int); create view v as select id from t; select object_name(object_id('v'))"));
+
+    [TestMethod]
+    public void ObjectName_TableType_ResolvableViaTypeTableObjectId()
+        => AreEqual("MyType", new Simulation().ExecuteScalar("create type MyType as table (id int); select object_name(type_table_object_id) from sys.table_types where name = 'MyType'"));
+
+    [TestMethod]
+    public void ObjectSchemaName_DefaultSchemaTable_ReturnsDbo()
+        => AreEqual("dbo", new Simulation().ExecuteScalar("create table foo (id int); select object_schema_name(object_id('foo'))"));
+
+    [TestMethod]
+    public void ObjectSchemaName_QualifiedSchemaTable_ReturnsSchema()
+        => AreEqual("audit", new Simulation().ExecuteScalar("create schema audit; create table audit.t (id int); select object_schema_name(object_id('audit.t'))"));
+
+    [TestMethod]
+    public void ObjectSchemaName_NullArg_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select object_schema_name(NULL)"));
+
+    [TestMethod]
+    public void ObjectSchemaName_MissingId_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select object_schema_name(99999)"));
+
+    [TestMethod]
+    public void ObjectSchemaName_WithDbIdArg_IgnoresArg()
+        => AreEqual("dbo", new Simulation().ExecuteScalar("create table foo (id int); select object_schema_name(object_id('foo'), 1)"));
+
+    [TestMethod]
+    public void RowConstructorIn_RejectedWithMatchingMsg4145()
+        => new Simulation().AssertSqlError(
+            "create table t (a int, b int); select * from t where (a, b) in ((1, 2))",
+            4145,
+            "An expression of non-boolean type specified in a context where a condition is expected, near ','.");
+}
diff --git a/SqlServerSimulator/Parser/Expression.cs b/SqlServerSimulator/Parser/Expression.cs
@@ -537,6 +537,8 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "ERROR_STATE" => new ErrorStateFunction(context),
                 "FIRST_VALUE" => WindowExpression.ParseFirstValue(context),
                 "JSON_MODIFY" => new JsonModify(context),
+                "OBJECT_NAME" => new ObjectName(context),
+                "SCHEMA_NAME" => new SchemaName(context),
                 "SYSDATETIME" => new CurrentTimeFunction(context, CurrentTimeKind.SysDateTime),
                 "TRY_CONVERT" => new ConvertExpression(context, tryMode: true),
                 _ => null
@@ -579,6 +581,12 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             18 => uppercaseName switch
             {
                 "DATETIME2FROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.DateTime2FromParts),
+                "OBJECT_SCHEMA_NAME" => new ObjectSchemaName(context),
+                _ => null
+            },
+            21 => uppercaseName switch
+            {
+                "APPROX_COUNT_DISTINCT" => AggregateExpression.Parse(context, AggregateKind.ApproxCountDistinct),
                 _ => null
             },
             22 => uppercaseName switch
@@ -591,11 +599,6 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "DATETIMEOFFSETFROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.DateTimeOffsetFromParts),
                 _ => null
             },
-            21 => uppercaseName switch
-            {
-                "APPROX_COUNT_DISTINCT" => AggregateExpression.Parse(context, AggregateKind.ApproxCountDistinct),
-                _ => null
-            },
             _ => (Expression?)null
         } ?? throw SimulatedSqlException.UnrecognizedBuiltInFunction(name);
     }
diff --git a/SqlServerSimulator/Parser/Expressions/ObjectName.cs b/SqlServerSimulator/Parser/Expressions/ObjectName.cs
@@ -0,0 +1,60 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>OBJECT_NAME(object_id [, database_id])</c>: returns the leaf
+/// name of the object with the given <c>object_id</c>, or NULL when not
+/// found. The optional database-id argument is accepted and ignored —
+/// the simulator hosts one database per <see cref="Simulation"/> instance.
+/// Walks <see cref="Database.Schemas"/> → <see cref="Schema.SchemaObjects"/>
+/// (the shared object-name namespace: tables / views / functions /
+/// procedures / sequences / triggers) plus <see cref="Schema.TableTypes"/>.
+/// Probe-confirmed against SQL Server 2025 (2026-05-13): NULL argument
+/// returns NULL; missing / negative id returns NULL; result type is
+/// <see cref="SqlType.SystemName"/>.
+/// </summary>
+internal sealed class ObjectName : Expression
+{
+    private readonly Expression idArg;
+
+    public ObjectName(ParserContext context)
+    {
+        this.idArg = Parse(context);
+        if (context.Token is Tokens.Operator { Character: ',' })
+        {
+            // database_id arg: accepted and ignored (single-DB simulator).
+            _ = Parse(context.MoveNextRequiredReturnSelf());
+            if (context.Token is Tokens.Operator { Character: ',' })
+                throw SimulatedSqlException.FunctionRequiresNArguments("object_name", 2);
+        }
+        if (context.Token is not Tokens.Operator { Character: ')' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+    }
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        var idValue = this.idArg.Run(runtime);
+        if (idValue.IsNull)
+            return SqlValue.Null(SqlType.SystemName);
+        var id = idValue.CoerceTo(SqlType.Int32).AsInt32;
+        foreach (var schema in runtime.Batch.CurrentDatabase.Schemas.Values)
+        {
+            foreach (var obj in schema.SchemaObjects())
+            {
+                if (obj.ObjectId == id)
+                    return SqlValue.FromString(SqlType.SystemName, obj.Name);
+            }
+            foreach (var tableType in schema.TableTypes.Values)
+            {
+                if (tableType.ObjectId == id)
+                    return SqlValue.FromString(SqlType.SystemName, tableType.Name);
+            }
+        }
+        return SqlValue.Null(SqlType.SystemName);
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.SystemName;
+
+    internal override string DebugDisplay() => $"OBJECT_NAME({this.idArg.DebugDisplay()})";
+}
diff --git a/SqlServerSimulator/Parser/Expressions/ObjectSchemaName.cs b/SqlServerSimulator/Parser/Expressions/ObjectSchemaName.cs
@@ -0,0 +1,59 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>OBJECT_SCHEMA_NAME(object_id [, database_id])</c>: returns the
+/// name of the schema that owns the object with the given <c>object_id</c>,
+/// or NULL when not found. The optional database-id argument is accepted
+/// and ignored (single-database simulator). Companion to
+/// <see cref="ObjectName"/> — same lookup walk over
+/// <see cref="Database.Schemas"/> → <see cref="Schema.SchemaObjects"/>
+/// plus <see cref="Schema.TableTypes"/>; this variant returns the owning
+/// schema's <see cref="Schema.Name"/> instead of the object's leaf.
+/// Probe-confirmed against SQL Server 2025 (2026-05-13).
+/// </summary>
+internal sealed class ObjectSchemaName : Expression
+{
+    private readonly Expression idArg;
+
+    public ObjectSchemaName(ParserContext context)
+    {
+        this.idArg = Parse(context);
+        if (context.Token is Tokens.Operator { Character: ',' })
+        {
+            // database_id arg: accepted and ignored (single-DB simulator).
+            _ = Parse(context.MoveNextRequiredReturnSelf());
+            if (context.Token is Tokens.Operator { Character: ',' })
+                throw SimulatedSqlException.FunctionRequiresNArguments("object_schema_name", 2);
+        }
+        if (context.Token is not Tokens.Operator { Character: ')' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+    }
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        var idValue = this.idArg.Run(runtime);
+        if (idValue.IsNull)
+            return SqlValue.Null(SqlType.SystemName);
+        var id = idValue.CoerceTo(SqlType.Int32).AsInt32;
+        foreach (var schema in runtime.Batch.CurrentDatabase.Schemas.Values)
+        {
+            foreach (var obj in schema.SchemaObjects())
+            {
+                if (obj.ObjectId == id)
+                    return SqlValue.FromString(SqlType.SystemName, schema.Name);
+            }
+            foreach (var tableType in schema.TableTypes.Values)
+            {
+                if (tableType.ObjectId == id)
+                    return SqlValue.FromString(SqlType.SystemName, schema.Name);
+            }
+        }
+        return SqlValue.Null(SqlType.SystemName);
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.SystemName;
+
+    internal override string DebugDisplay() => $"OBJECT_SCHEMA_NAME({this.idArg.DebugDisplay()})";
+}
diff --git a/SqlServerSimulator/Parser/Expressions/SchemaName.cs b/SqlServerSimulator/Parser/Expressions/SchemaName.cs
@@ -0,0 +1,47 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>SCHEMA_NAME([id])</c>: returns the name of the schema with the
+/// given <c>schema_id</c>, or the caller's default schema name (<c>dbo</c>)
+/// when called with no argument. Probe-confirmed against SQL Server 2025
+/// (2026-05-13): no-arg returns <c>dbo</c> for the user the simulator
+/// emulates; a non-existent or negative id returns NULL; a NULL argument
+/// returns NULL. Result type is <see cref="SqlType.SystemName"/> (sysname /
+/// nvarchar(128)) — mirrors <see cref="SchemaId"/>'s int-result inverse.
+/// </summary>
+internal sealed class SchemaName : Expression
+{
+    private readonly Expression? idArg;
+
+    public SchemaName(ParserContext context)
+    {
+        if (context.Token is Tokens.Operator { Character: ')' })
+            return;
+        this.idArg = Parse(context);
+        if (context.Token is not Tokens.Operator { Character: ')' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+    }
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        if (this.idArg is null)
+            return SqlValue.FromString(SqlType.SystemName, Database.DefaultSchemaName);
+        var idValue = this.idArg.Run(runtime);
+        if (idValue.IsNull)
+            return SqlValue.Null(SqlType.SystemName);
+        var id = idValue.CoerceTo(SqlType.Int32).AsInt32;
+        foreach (var schema in runtime.Batch.CurrentDatabase.Schemas.Values)
+        {
+            if (schema.SchemaId == id)
+                return SqlValue.FromString(SqlType.SystemName, schema.Name);
+        }
+        return SqlValue.Null(SqlType.SystemName);
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.SystemName;
+
+    internal override string DebugDisplay() =>
+        this.idArg is null ? "SCHEMA_NAME()" : $"SCHEMA_NAME({this.idArg.DebugDisplay()})";
+}
diff --git a/docs/claude/schemas.md b/docs/claude/schemas.md
@@ -40,3 +40,13 @@ Every `HeapTable` carries a stable per-database `int ObjectId` assigned at CREAT
 - **Temp-table divergence**: `OBJECT_ID('#foo')` resolves the session's `#foo` directly because `BatchContext.TryResolveTable` routes `#` leaves to the connection's temp dict regardless of qualifier. Real SQL Server requires the explicit `tempdb..#foo` three-part form (since unqualified resolution targets the current DB, not tempdb). The simulator's existing temp-routing simplification carries through; `OBJECT_ID('tempdb..#foo')` also works (probe-confirmed real behavior).
 - **Bracket-handling fidelity gap**: the runtime-string name parser strips bracket pairs at segment level (`'[dbo].[foo]'` → `dbo`+`foo`) and decodes `]]` → `]` inside brackets — but bracketed segments containing a literal `.` (`'[a.b].[c]'`, the literal-dot case) don't parse correctly (split on `.` happens before bracket-aware tokenization). Rare in practice; revisit if a real app hits it.
 - **Arity**: too-few-args (`OBJECT_ID()`) currently surfaces as Msg 102 (the inner Parse failure path) rather than Msg 174 — same pattern as other built-ins; the simulator doesn't enforce min-args. Too-many-args raises Msg 174 verbatim.
+
+## Id → name scalars
+
+**`SCHEMA_NAME([id])`** (`Parser/Expressions/SchemaName.cs`): the `int → name` inverse of `SCHEMA_ID`. With an int `schema_id` argument, walks `Database.Schemas.Values` for the matching `Schema.SchemaId` and returns its `Name`. No-arg returns `Database.DefaultSchemaName` (`"dbo"`) — matches real SQL Server's "default schema for the current user" behavior (single-principal simulator). NULL arg / missing id / negative id → NULL. Result type: `sysname` (nvarchar(128)).
+
+**`OBJECT_NAME(object_id [, database_id])`** (`Parser/Expressions/ObjectName.cs`): walks every `Schema.SchemaObjects()` (the shared object-name namespace: heap tables / views / functions / procedures / sequences / triggers) plus `Schema.TableTypes` and returns the matching object's leaf `Name`. The optional `database_id` argument is parsed and ignored (single-database simulator — real SQL Server uses it to scope across attached DBs). NULL arg / missing id → NULL. Result type: `sysname`.
+
+**`OBJECT_SCHEMA_NAME(object_id [, database_id])`** (`Parser/Expressions/ObjectSchemaName.cs`): same lookup walk as `OBJECT_NAME`; returns the owning `Schema.Name` instead of the object leaf. Same NULL / ignored-db_id semantics. Result type: `sysname`.
+
+- **TableType / sys.objects gap**: `OBJECT_NAME` and `OBJECT_SCHEMA_NAME` both resolve table-type objects through `Schema.TableTypes` directly, so `SELECT OBJECT_NAME(type_table_object_id) FROM sys.table_types` works. `sys.objects` itself doesn't currently surface TT-rows (separate namespace per the `SchemaObjects()` enumerator's design), so the same lookup via `sys.objects WHERE type = 'TT'` returns empty. Closing the gap is a `BuiltInResources` change, not a scalar change.
