PRIMARY KEY / UNIQUE on PERSISTED computed columns — lifts the broad NotSupportedException at Simulation.Create.cs lines 1073 (ParseTableKeyConstraint pending-computed-name scan) and 1129 (ResolveKeyConstraints final validator). PERSISTED computed columns are key-eligible because they carry a real storage ordinal (HeapColumn.IsStored=true via IsPersisted) — the existing EnforceKeyConstraints + EnforceUniqueIndexes loops read them by storage-ordinal lookup like any other stored column, so no change to the enforcement path is needed. ParseTableKeyConstraint's pending-computed branch now sets found = i and breaks instead of throwing — the column's null slot in heapColumns gets filled during the computed-column materialization pass; ResolveKeyConstraints then sees the finished HeapColumn and applies the new gate. Inline form (c AS expr PERSISTED NOT NULL PRIMARY KEY) is supported by extending the computed-column branch in ParseOneColumnIntoLists to consume an optional trailing PRIMARY KEY / UNIQUE keyword after the PERSISTED-[NOT-NULL] suffix and add the constraint to pendingKeys with the column's index. Rejection paths match probe-confirmed real SQL Server 2025 behavior: PK on non-persisted at CREATE TABLE → new Msg 1711 factory ComputedColumnPkRequiresPersisted ("The computed column has to be persisted and not nullable."); PK on non-persisted at ALTER ADD → existing Msg 8111 via the non-persisted-implies-nullable shortcut (probe-confirmed real SQL Server uses the different code at ALTER vs CREATE — both observable through the simulator's existing nullable-check path without special-casing); PK on PERSISTED nullable computed at either CREATE or ALTER → existing Msg 8111 (computed columns default to nullable=true unless explicitly PERSISTED NOT NULL — divergence from real SQL Server which appears to auto-promote-to-NOT-NULL when used as PK, documented as deferred since EF Core always emits explicit nullability and so apps don't reach the path); UNIQUE on non-persisted at CREATE TABLE → NotSupportedException (real SQL Server allows; deferred because enforcement would need per-row expression evaluation in EnforceUniqueIndexes / EnforceKeyConstraints rather than storage-ordinal lookup); same NotSupportedException at ALTER ADD (new guard in Simulation.AlterTableConstraint.cs's ParseAddKeyConstraint covers UNIQUE that the existing Msg 8111 nullable check doesn't catch). Existing obsolete test KeyConstraintTests.PrimaryKey_OnComputedColumn_NotSupported rewritten + 14 new tests cover the full surface: inline + table-level + ALTER ADD shapes across PK / UNIQUE; CREATE-time + ALTER-time + INSERT-time enforcement; compound PK with regular+computed columns; Msg 1711 / Msg 8111 / Msg 2627 / Msg 1505 paths; NotSupportedException for both non-persisted UNIQUE shapes. CLAUDE.md "Not modeled" entry rewritten — the broad "PK/UNIQUE on computed column" bullet now scoped down to "UNIQUE on a non-persisted computed column", explaining the storage-ordinal-vs-expression-evaluation distinction and the orthogonal Msg 4936 (PERSISTED determinism gate) gap that remains unenforced.

RyanLamansky · RyanLamansky · commit 8f65789fed21 · 2026-05-13T21:19:26.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -166,7 +166,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - `CONVERT` / `TRY_CONVERT` style codes other than `0` / `1` / `10` / `12` / `23` / `101` / `102` / `103` / `110` / `112` / `120` / `121` / `126` / `127` (datetime ⇄ string, both directions; ISO 8601 + regional formats) and `0` / `1` / `2` (money → string). See [`docs/claude/casting.md`](docs/claude/casting.md).
 - `LEN(ntext)` raising Msg 8116; legacy `READTEXT` / `WRITETEXT` / `UPDATETEXT`.
 - MERGE source as a CTE-headed SELECT (`USING (WITH cte AS … SELECT …)`) — Selection.Parse's CTE entry doesn't reach the USING-clause grammar; wrap the CTE inside a regular SELECT instead. MERGE inside a CTE body, multi-statement MERGE WHEN-clause bodies, and `MERGE INTO <view>` (real SQL Server's updatable-view MERGE) are also deferred.
-- `PRIMARY KEY` / `UNIQUE` on a computed column (`NotSupportedException`).
+- `UNIQUE` on a *non-persisted* computed column (`NotSupportedException`) — `PRIMARY KEY` / `UNIQUE` on a `PERSISTED` computed column ships (inline + table-level + ALTER ADD CONSTRAINT shapes; PK on non-persisted raises Msg 1711 at CREATE TABLE / Msg 8111 at ALTER ADD per probe). Non-persisted UNIQUE would need per-row expression evaluation in `EnforceKeyConstraints` / `EnforceUniqueIndexes` rather than storage-ordinal lookup. The orthogonal Msg 4936 determinism gate for PERSISTED computed columns themselves (rejecting GETDATE / NEWID etc.) isn't enforced either; non-deterministic PERSISTED computed columns silently materialize.
 - Heap allocation tracking (flat page list, no IAM/PFS).
 - **Table-variable named constraints / foreign keys** — `DECLARE @t TABLE (...)` shares its column-list parser with CREATE TABLE (see `docs/claude/table-variables.md`); column features (IDENTITY / UNIQUE / inline + table-level CHECK / computed columns / rowversion) all ship, alongside per-statement-atomic mutations and `OUTPUT … INTO <target>` for both `@t` and regular tables. Named constraints (`CONSTRAINT pk1 PRIMARY KEY`) and `FOREIGN KEY` raise Msg 102 (matches probe — real SQL Server's grammar disallows both shapes inside `DECLARE @t TABLE`). Multi-variable DECLARE with a table variable (`DECLARE @t1 TABLE (...), @t2 TABLE (...)`) and mixed scalar+table DECLARE also raise Msg 102/156. `SET IDENTITY_INSERT @t ON` likewise raises Msg 102 (probe-confirmed: there's no way to force a specific value into a table-variable identity column).
 - **Global temp tables (`##foo`)** — `NotSupportedException` at parse. Local `#foo` works; the lifecycle for global temps (drops when creator session closes, visible across sessions) is the deferred scope.
diff --git a/SqlServerSimulator.Tests/KeyConstraintTests.cs b/SqlServerSimulator.Tests/KeyConstraintTests.cs
@@ -317,15 +317,139 @@ insert t values (1, 100)
         Assert.Contains("UNIQUE KEY constraint 'uq_t'", uqEx.Message);
     }
 
+    // --- PK / UNIQUE on computed columns ---
+
+    [TestMethod]
+    public void PrimaryKey_OnNonPersistedComputed_RaisesMsg1711()
+    {
+        // Probe-confirmed: real SQL Server raises Msg 1711 at CREATE TABLE when
+        // PK targets a non-persisted computed column.
+        var ex = new Simulation().AssertSqlError(
+            "create table t (a int not null, c as a + 1, primary key (c))", 1711);
+        Assert.Contains("computed column has to be persisted", ex.Message);
+        Assert.Contains("'c'", ex.Message);
+    }
+
+    [TestMethod]
+    public void PrimaryKey_OnPersistedNullableComputed_RaisesMsg8111()
+    {
+        // PERSISTED without an explicit NOT NULL keeps the simulator's
+        // computed-column nullability defaulted to true; the existing PK
+        // nullable check catches it.
+        _ = new Simulation().AssertSqlError(
+            "create table t (a int null, c as a + 1 persisted, primary key (c))", 8111);
+    }
+
+    [TestMethod]
+    public void PrimaryKey_OnPersistedNotNullComputed_TableLevel_Succeeds()
+        => Assert.AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (a int not null, c as a + 1 persisted not null, primary key (c));
+            insert t(a) values (1), (2);
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void PrimaryKey_OnPersistedNotNullComputed_Inline_Succeeds()
+        => Assert.AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (a int not null, c as a + 1 persisted not null primary key);
+            insert t(a) values (1), (2);
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void PrimaryKey_OnPersistedComputed_EnforcesUniqueness()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table t (a int not null, c as a + 1 persisted not null, primary key (c));
+            insert t(a) values (1), (2)
+            """);
+        // a=1 → c=2 collides with existing c=2 from a=1
+        var ex = simulation.AssertSqlError("insert t(a) values (1)", 2627);
+        Assert.Contains("PRIMARY KEY", ex.Message);
+        Assert.Contains("(2)", ex.Message);
+    }
+
+    [TestMethod]
+    public void PrimaryKey_OnPersistedComputed_Compound_Succeeds()
+        => Assert.AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (a int not null, c as a + 1 persisted not null, x int not null,
+                            primary key (a, c));
+            insert t(a, x) values (1, 100), (2, 200);
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Unique_OnPersistedComputed_TableLevel_Succeeds()
+        => Assert.AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (a int not null, c as a * 10 persisted, unique (c));
+            insert t(a) values (1), (2);
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Unique_OnPersistedComputed_EnforcesUniqueness()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table t (a int not null, c as a * 10 persisted, unique (c));
+            insert t(a) values (1), (2)
+            """);
+        var ex = simulation.AssertSqlError("insert t(a) values (1)", 2627);
+        Assert.Contains("UNIQUE KEY", ex.Message);
+        Assert.Contains("(10)", ex.Message);
+    }
+
     [TestMethod]
-    public void PrimaryKey_OnComputedColumn_NotSupported()
+    public void Unique_OnNonPersistedComputed_NotSupported()
     {
-        // Real SQL Server allows PK/UNIQUE on a computed column; simulator's v1 doesn't model this.
-        var ex = Assert.Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery(
-            "create table t (a int not null, c as a + 1, primary key (c))"));
-        Assert.Contains("computed column", ex.Message);
+        // Real SQL Server allows this; the simulator defers UNIQUE-on-non-
+        // persisted because enforcement would need per-row expression
+        // evaluation rather than storage-ordinal lookup.
+        _ = Assert.Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery(
+            "create table t (a int not null, c as a * 10, unique (c))"));
     }
 
+    [TestMethod]
+    public void AlterTable_AddPrimaryKey_OnPersistedComputed_Succeeds()
+        => Assert.AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (a int not null, c as a + 1 persisted not null);
+            insert t(a) values (1), (2);
+            alter table t add constraint pk_t primary key (c);
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void AlterTable_AddPrimaryKey_OnPersistedComputed_RejectsExistingDuplicate()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (a int not null, c as a + 1 persisted not null);
+            insert t(a) values (1), (1);
+            alter table t add constraint pk_t primary key (c)
+            """, 1505);
+
+    [TestMethod]
+    public void AlterTable_AddPrimaryKey_OnNonPersistedComputed_RaisesMsg8111()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (a int not null, c as a + 1);
+            alter table t add constraint pk_t primary key (c)
+            """, 8111);
+
+    [TestMethod]
+    public void AlterTable_AddUnique_OnPersistedComputed_Succeeds()
+        => Assert.AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (a int not null, c as a + 1 persisted);
+            insert t(a) values (1), (2);
+            alter table t add unique (c);
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void AlterTable_AddUnique_OnNonPersistedComputed_NotSupported()
+        => _ = Assert.Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery("""
+            create table t (a int not null, c as a + 1);
+            alter table t add unique (c)
+            """));
+
     [TestMethod]
     public void MergeInsert_DuplicateKey_RaisesMsg2627()
     {
diff --git a/SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs b/SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs
@@ -396,6 +396,15 @@ internal static SimulatedSqlException PrimaryKeyOnNullableColumn(string tableNam
     internal static SimulatedSqlException KeyColumnInvalidType(string columnName, string tableName) =>
         new($"Column '{columnName}' in table '{tableName}' is of a type that is invalid for use as a key column in an index.", 1919, 16, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 1711: <c>PRIMARY KEY</c> targeted a computed
+    /// column that isn't <c>PERSISTED</c>. Probe-confirmed at CREATE TABLE
+    /// (the ALTER-ADD-PK path raises Msg 8111 instead, via the non-persisted-
+    /// implies-nullable shortcut). Real SQL Server uses identical wording.
+    /// </summary>
+    internal static SimulatedSqlException ComputedColumnPkRequiresPersisted(string columnName, string tableName) =>
+        new($"Cannot define PRIMARY KEY constraint on column '{columnName}' in table '{tableName}'. The computed column has to be persisted and not nullable.", 1711, 16, 1);
+
     /// <summary>
     /// Mimics SQL Server error 8102: an UPDATE statement targeted an identity
     /// column. <c>SET IDENTITY_INSERT</c> only opens INSERT to identity
diff --git a/SqlServerSimulator/Simulation/Simulation.AlterTableConstraint.cs b/SqlServerSimulator/Simulation/Simulation.AlterTableConstraint.cs
@@ -261,6 +261,14 @@ private static bool ParseAddKeyConstraint(ParserContext context, MultiPartName t
             var col = table.Columns[fullOrdinals[i]];
             if (col.IsLob)
                 throw SimulatedSqlException.KeyColumnInvalidType(col.Name, table.Name);
+            // Non-persisted computed columns have no storage ordinal — UNIQUE
+            // on one would need expression evaluation in the enforcement loop
+            // (not modeled). PRIMARY KEY on a non-persisted computed already
+            // raised Msg 8111 above (computed columns are nullable by default
+            // and the existing nullable check catches it — probe-confirmed
+            // at ALTER ADD, the wording differs from CREATE TABLE's Msg 1711).
+            if (col.Computed is not null && !col.IsPersisted)
+                throw new NotSupportedException("UNIQUE on a non-persisted computed column isn't modeled.");
             storageOrdinals[i] = table.StorageOrdinals[fullOrdinals[i]];
         }
 
diff --git a/SqlServerSimulator/Simulation/Simulation.Create.cs b/SqlServerSimulator/Simulation/Simulation.Create.cs
@@ -545,9 +545,20 @@ internal static void ParseOneColumnIntoLists(
             context.MoveNextRequired();
             var computed = Expression.Parse(context);
             var (persisted, computedNullable) = ParseComputedSuffix(context);
-            pendingComputed.Add((heapColumns.Count, columnName.Value, computed, persisted, computedNullable));
+            var computedIndex = heapColumns.Count;
+            pendingComputed.Add((computedIndex, columnName.Value, computed, persisted, computedNullable));
             heapColumns.Add(null);
             explicitNull.Add(false);
+            // Inline PRIMARY KEY / UNIQUE after a computed column's
+            // PERSISTED [NOT NULL] suffix — probe-confirmed: `c AS expr
+            // PERSISTED NOT NULL PRIMARY KEY` is legal at CREATE TABLE.
+            // ResolveKeyConstraints applies the persisted/nullability gate
+            // after computed-column materialization.
+            if (context.Token is ReservedKeyword { Keyword: Keyword.Primary or Keyword.Unique })
+            {
+                var inlineKind = ParseInlineKeyKindAndModifiers(context);
+                pendingKeys.Add((inlineKind, null, [computedIndex]));
+            }
             return;
         }
 
@@ -1070,8 +1081,18 @@ private static void ParseTableLevelConstraint(
                     foreach (var pending in pendingComputed)
                     {
                         if (pending.Index == i && Collation.Default.Equals(pending.Name, keyColumn.Value))
-                            throw new NotSupportedException("PRIMARY KEY/UNIQUE on a computed column.");
+                        {
+                            // Computed columns participate as key columns when
+                            // PERSISTED — validated in ResolveKeyConstraints
+                            // after computed-column materialization fills the
+                            // null slot. Record the ordinal; the persistence
+                            // gate fires later.
+                            found = i;
+                            break;
+                        }
                     }
+                    if (found >= 0)
+                        break;
                 }
             }
             if (found < 0)
@@ -1097,11 +1118,12 @@ private static void ParseTableLevelConstraint(
     /// by storage ordinal. Enforces SQL Server's compile-time rules: at most
     /// one PRIMARY KEY per table (Msg 8110), no PK on a column whose declared
     /// nullability is NULL (Msg 8111 — also fires for table-level PK on a
-    /// column declared NULL), no key column of LOB type (Msg 1919). Generates
-    /// a SQL-Server-shaped auto name for any unnamed constraint
+    /// column declared NULL), no key column of LOB type (Msg 1919),
+    /// computed-column participation requires <see cref="HeapColumn.IsPersisted"/>
+    /// (PK on a non-persisted computed → Msg 1711; UNIQUE on a non-persisted
+    /// computed → <see cref="NotSupportedException"/>, deferred). Generates a
+    /// SQL-Server-shaped auto name for any unnamed constraint
     /// (<c>PK__&lt;table&gt;__&lt;hex&gt;</c> / <c>UQ__&lt;table&gt;__&lt;hex&gt;</c>).
-    /// Computed columns are not yet supported as key participants — those
-    /// raise <see cref="NotSupportedException"/>.
     /// </summary>
     internal static KeyConstraint[] ResolveKeyConstraints(
         string tableName,
@@ -1125,8 +1147,12 @@ internal static KeyConstraint[] ResolveKeyConstraints(
             {
                 var fullOrdinal = pending.FullOrdinals[i];
                 var column = heapColumns[fullOrdinal];
-                if (column.Computed is not null)
-                    throw new NotSupportedException("PRIMARY KEY/UNIQUE on a computed column.");
+                if (column.Computed is not null && !column.IsPersisted)
+                {
+                    if (pending.Kind == KeyConstraintKind.PrimaryKey)
+                        throw SimulatedSqlException.ComputedColumnPkRequiresPersisted(column.Name, tableName);
+                    throw new NotSupportedException("UNIQUE on a non-persisted computed column isn't modeled.");
+                }
                 if (column.IsLob)
                     throw SimulatedSqlException.KeyColumnInvalidType(column.Name, tableName);
                 if (pending.Kind == KeyConstraintKind.PrimaryKey && column.Nullable)
