ALTER TABLE … SET (SYSTEM_VERSIONING = OFF) for temporal-table teardown: new TryParseAlterTable parser (only this shape ships; other ALTER TABLE forms raise NotSupportedException) clears the parent's HeapTable.SystemVersioning link and the sibling's IsHistoryTable flag, releasing both tables to regular status so subsequent DROP TABLE succeeds. Per probe (2026-05-13 with elevated permissions): both tables flip to sys.tables.temporal_type = 0, parent's period columns retain AS_ROW_START / AS_ROW_END + is_hidden, and crucially INSERT continues to auto-populate the period columns after SET OFF (the engine keys the auto-populate on the per-column GENERATED ALWAYS marker, not the table-level versioning link). The simulator's Simulation.Insert.cs gate was tightened from "system-versioned" to "column has GeneratedAs marker" to match, with regression coverage; UPDATE/DELETE history-write paths correctly remain gated on the table-level link (probe-confirmed they no-op after SET OFF). New error factories: Msg 13591 (not-versioned target — fires for plain regular tables and the history sibling itself) and Msg 4902 (alter-table-specific table-not-found, distinct from Msg 208's generic wording). 8 new TemporalTableTests cover round-trip teardown, hidden-column persistence, post-SET-OFF INSERT auto-populate, post-SET-OFF Msg 13536, both 13591 paths, 4902, and the NotSupportedException shape-rejection. docs/claude/temporal-tables.md "Not modeled" trimmed to the SET-versioning-ON direction; CLAUDE.md trigger phrase extended and a new "Not modeled" bullet declares the broader ALTER TABLE grammar as unsupported.

RyanLamansky · RyanLamansky · commit d277b205325a · 2026-05-13T15:19:08.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -149,7 +149,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Touching `CREATE TYPE … AS TABLE`, `DECLARE @t MyType`, TVP procedure parameters / `READONLY`, or the ADO.NET `DbParameter.TypeName` extension (DataTable / IDataReader as a TVP value source)** → [`docs/claude/table-valued-parameters.md`](docs/claude/table-valued-parameters.md).
 - **Touching `CREATE SEQUENCE` / `ALTER SEQUENCE` / `DROP SEQUENCE`, `NEXT VALUE FOR`, the per-row dedup mechanism (`BatchContext.CurrentRowStamp` / `SequenceRowCache`), or `sys.sequences`** → [`docs/claude/sequences.md`](docs/claude/sequences.md).
 - **Touching `CREATE TRIGGER` / `ALTER TRIGGER` / `DROP TRIGGER` / `DISABLE`/`ENABLE TRIGGER`, the `INSERTED` / `DELETED` pseudo-table materialization, the `TriggerFrame` / `FiringTriggerIds` recursion guard, `TRIGGER_NESTLEVEL()`, or `sys.triggers`** → [`docs/claude/triggers.md`](docs/claude/triggers.md).
-- **Touching `PERIOD FOR SYSTEM_TIME` / `GENERATED ALWAYS AS ROW START / END [HIDDEN]` / `WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = …))` DDL, the auto-created history sibling, `FOR SYSTEM_TIME ALL / AS OF` query syntax, or `HeapTable.PeriodColumns` / `HeapTable.SystemVersioning` / `HeapColumn.GeneratedAs` / `HeapColumn.IsHidden`** → [`docs/claude/temporal-tables.md`](docs/claude/temporal-tables.md).
+- **Touching `PERIOD FOR SYSTEM_TIME` / `GENERATED ALWAYS AS ROW START / END [HIDDEN]` / `WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = …))` DDL, `ALTER TABLE … SET (SYSTEM_VERSIONING = OFF)`, the auto-created history sibling, `FOR SYSTEM_TIME ALL / AS OF` query syntax, or `HeapTable.PeriodColumns` / `HeapTable.SystemVersioning` / `HeapColumn.GeneratedAs` / `HeapColumn.IsHidden`** → [`docs/claude/temporal-tables.md`](docs/claude/temporal-tables.md).
 - **Adding a new top-level statement parser or changing the dispatch loop's statement-separator rules** → [`docs/claude/grammar.md`](docs/claude/grammar.md) + [`docs/claude/control-flow.md`](docs/claude/control-flow.md).
 
 ## Not modeled
@@ -174,6 +174,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - T-SQL `GOTO` / labels — `IF` / `BEGIN…END` / `WHILE` / `BREAK` / `CONTINUE` / `RETURN` (bare + UDF-body and stored-procedure-body value form) ship; unconditional jumps don't.
 - Multi-statement table-valued functions (`RETURNS @t TABLE (...) AS BEGIN ... END`), CLR functions, INSTEAD OF UPDATE / DELETE on *non-updatable* views (INSTEAD OF INSERT on any view ships; INSTEAD OF UPDATE / DELETE on updatable single-base views ships). DDL / logon triggers also unmodeled. Scalar UDFs, inline TVFs, views, DML-through-views (single-source updatable shape), stored procedures (including CREATE / ALTER / DROP, EXEC with input/output/default params, `@rc = EXEC` return-code capture, `CommandType.StoredProcedure`, `EXEC (@sql)` and `sp_executesql` dynamic SQL), user-defined table types + table-valued parameters (CREATE TYPE … AS TABLE / DROP TYPE / DECLARE @t MyType / READONLY proc params / EXEC with TVP arg / ADO.NET Structured parameter via the `DbParameter.TypeName` C# 14 extension property + DataTable/IDataReader sources), sequence objects (CREATE / ALTER / DROP SEQUENCE / NEXT VALUE FOR / sys.sequences — supports EF Core HiLo identity strategy end-to-end), and DML triggers (CREATE / ALTER / CREATE OR ALTER / DROP TRIGGER, FOR-as-AFTER synonym, AFTER on heap tables + INSTEAD OF on heap tables / views, multi-action INSERT,UPDATE,DELETE, INSERTED/DELETED pseudo-tables, multiple AFTER triggers per parent / one INSTEAD OF per action per target (Msg 2111), DISABLE/ENABLE TRIGGER, TRIGGER_NESTLEVEL(), direct-recursion suppression matching RECURSIVE_TRIGGERS OFF, sys.triggers + sys.objects integration, trigger-error rolls back firing DML, MERGE per-action routing through INSTEAD OF, DROP TABLE / DROP VIEW cascade-drops attached triggers) ship (see `docs/claude/programmable.md`, `docs/claude/table-valued-parameters.md`, `docs/claude/sequences.md`, and `docs/claude/triggers.md`). JOIN-view single-base-table UPDATE/DELETE, OUTPUT through views, and multi-source alias-form UPDATE/DELETE through views are deferred (Msg 4405 or `NotSupportedException` at the DML site). `BEGIN ATOMIC` / `BEGIN DISTRIBUTED TRANSACTION` raise `NotSupportedException` at dispatch. Value-form `RETURN N` is legal inside a scalar-UDF body and a stored-procedure body; bare batch / dynamic-SQL scope raises Msg 178. TRY/CATCH + THROW + RAISERROR (printf-style `%s %d/%i %u %o %x %X %% %ld %I64d` with width / precision / left-align / zero-pad; severity routing 0-10 informational vs 11-18 catchable; `WITH SETERROR`/`NOWAIT` ship, `WITH LOG` uniformly raises Msg 2778; numeric `msg_id` raises Msg 2732 for 50000 / `< 13000` and Msg 18054 otherwise — `sys.messages` registry / `sp_addmessage` not modeled) + live `@@ERROR` + `ERROR_*()` functions ship (see `docs/claude/control-flow.md`).
 - **`PRINT` message capture** — the statement parses + evaluates the operand (so operand-side errors like Msg 245 surface), but the message is discarded. `DbConnection` has no `InfoMessage` event (that's a `SqlConnection` extension), so adding a public observability surface would mean a new event on `SimulatedDbConnection`. Defer until an application needs it.
+- **`ALTER TABLE` grammar beyond `SET (SYSTEM_VERSIONING = OFF)`** — only the SET-versioning-off shape ships (see [`docs/claude/temporal-tables.md`](docs/claude/temporal-tables.md)). ADD / DROP COLUMN, ADD / DROP CONSTRAINT, DROP PERIOD FOR SYSTEM_TIME, REBUILD, SWITCH PARTITION, the SET-versioning-on direction, and every other shape raise `NotSupportedException` at the post-name dispatch point.
 - `hierarchyid`, `geography`, `geometry`.
 
 ## Quirks (modeled, not byte-identical to SQL Server)
diff --git a/SqlServerSimulator.Tests/TemporalTableTests.cs b/SqlServerSimulator.Tests/TemporalTableTests.cs
@@ -179,4 +179,103 @@ public void Ddl_GeneratedColumnNotDatetime2_RaisesMsg13501()
             "create table t (id int, Vf datetime generated always as row start hidden not null, Vt datetime generated always as row end hidden not null, period for system_time (Vf, Vt))",
             13501,
             "Temporal generated always column 'Vf' has invalid data type.");
+
+    [TestMethod]
+    public void AlterSystemVersioningOff_PermitsDropOnParentAndHistory()
+    {
+        var simulation = new Simulation();
+        simulation.ExecuteBatches(
+            CreateTemporalCustomers,
+            "insert Customers (Id, Name) values (1, 'a')",
+            "update Customers set Name = 'A' where Id = 1",
+            "alter table Customers set (system_versioning = off)",
+            "drop table Customers",
+            "drop table CustomersHistory");
+        // Both tables gone from sys.tables after the flip-then-drop.
+        AreEqual(0, simulation.ExecuteScalar("select count(*) from sys.tables where name in ('Customers', 'CustomersHistory')"));
+    }
+
+    [TestMethod]
+    public void Insert_AfterAlterOff_StillAutoPopulatesPeriodColumns()
+    {
+        // Probed 2026-05-13: real SQL Server keeps auto-populating the period
+        // columns on INSERT after SET OFF — the GENERATED ALWAYS markers on
+        // the parent's columns persist independently of the versioning link,
+        // and the engine respects them. Without this regression the simulator
+        // would diverge: a post-SET-OFF INSERT would leave Vf/Vt as raw
+        // NULLs (failing NOT NULL) or unset zeros (depending on path).
+        var simulation = new Simulation();
+        simulation.ExecuteBatches(
+            CreateTemporalCustomers,
+            "alter table Customers set (system_versioning = off)",
+            "insert Customers (Id, Name) values (1, 'alice')");
+        AreEqual(DateTime.MaxValue.Date, ((DateTime)simulation.ExecuteScalar("select Vt from Customers where Id = 1")!).Date);
+    }
+
+    [TestMethod]
+    public void Insert_AfterAlterOff_RejectsExplicitGeneratedColumn()
+    {
+        // Probed: Msg 13536 still fires post-SET-OFF (GENERATED ALWAYS marker
+        // persists on the column, independently of the versioning link).
+        // Pre-existing simulator path keys off column-level GeneratedAs and
+        // not on table-level SystemVersioning, so this should pass without
+        // changes — pin it down so future refactors can't regress.
+        var simulation = new Simulation();
+        simulation.ExecuteBatches(
+            CreateTemporalCustomers,
+            "alter table Customers set (system_versioning = off)");
+        simulation.AssertSqlError(
+            "insert Customers (Id, Name, Vf) values (1, 'a', sysutcdatetime())",
+            13536,
+            "Cannot insert an explicit value into a GENERATED ALWAYS column in table 'simulated.dbo.Customers'. Use INSERT with a column list to exclude the GENERATED ALWAYS column, or insert a DEFAULT into GENERATED ALWAYS column.");
+    }
+
+    [TestMethod]
+    public void AlterSystemVersioningOff_PreservesHiddenColumns()
+    {
+        var simulation = new Simulation();
+        simulation.ExecuteBatches(
+            CreateTemporalCustomers,
+            "alter table Customers set (system_versioning = off)");
+        // Probed: GENERATED ALWAYS + HIDDEN column metadata persists after SET
+        // OFF on the parent. SELECT * still excludes the hidden period
+        // columns and they're still reachable by explicit name.
+        using var con = simulation.CreateOpenConnection();
+        using var cmd = con.CreateCommand();
+        cmd.CommandText = "select * from Customers";
+        using var r = cmd.ExecuteReader();
+        AreEqual(2, r.FieldCount);
+        AreEqual("Id", r.GetName(0));
+        AreEqual("Name", r.GetName(1));
+    }
+
+    [TestMethod]
+    public void AlterSystemVersioningOff_OnRegularTable_RaisesMsg13591()
+        => new Simulation().AssertSqlError(
+            "create table t (id int); alter table t set (system_versioning = off)",
+            13591,
+            "SYSTEM_VERSIONING is not turned ON for table 'simulated.dbo.t'.");
+
+    [TestMethod]
+    public void AlterSystemVersioningOff_OnHistorySibling_RaisesMsg13591()
+        => new Simulation().AssertSqlError(
+            $"{CreateTemporalCustomers}; alter table CustomersHistory set (system_versioning = off)",
+            13591,
+            "SYSTEM_VERSIONING is not turned ON for table 'simulated.dbo.CustomersHistory'.");
+
+    [TestMethod]
+    public void AlterTable_NonexistentTarget_RaisesMsg4902()
+        => new Simulation().AssertSqlError(
+            "alter table dbo.tNoSuch set (system_versioning = off)",
+            4902,
+            "Cannot find the object \"dbo.tNoSuch\" because it does not exist or you do not have permissions.");
+
+    [TestMethod]
+    public void AlterTable_UnsupportedShape_RaisesNotSupported()
+    {
+        var simulation = new Simulation();
+        simulation.ExecuteBatches(CreateTemporalCustomers);
+        _ = ThrowsExactly<NotSupportedException>(
+            () => simulation.ExecuteNonQuery("alter table Customers add NewCol int"));
+    }
 }
diff --git a/SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs b/SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs
@@ -601,4 +601,27 @@ internal static SimulatedSqlException CannotInsertIntoTemporalHistoryTable(strin
     /// </summary>
     internal static SimulatedSqlException CannotDropTemporalTable(string qualifiedTableName) =>
         new($"Drop table operation failed on table '{qualifiedTableName}' because it is not a supported operation on system-versioned temporal tables.", 13552, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 13591: <c>ALTER TABLE … SET (SYSTEM_VERSIONING
+    /// = OFF)</c> targeted a table that isn't system-versioned. Fires for
+    /// plain regular tables and for the history sibling itself (the history
+    /// sibling carries the <c>HISTORY_TABLE</c> role but doesn't "have"
+    /// versioning — only the parent does). Probe-confirmed wording against
+    /// SQL Server 2025.
+    /// </summary>
+    internal static SimulatedSqlException SystemVersioningNotOn(string qualifiedTableName) =>
+        new($"SYSTEM_VERSIONING is not turned ON for table '{qualifiedTableName}'.", 13591, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 4902: <c>ALTER TABLE</c> named a target that
+    /// doesn't resolve to an existing table. The qualified name is reported
+    /// verbatim in double-quotes (distinct from the single-quoted form Msg
+    /// 208 uses for un-qualified DML name resolution). Probe-confirmed
+    /// wording against SQL Server 2025: <c>ALTER TABLE dbo.tNoSuch SET
+    /// (SYSTEM_VERSIONING = OFF)</c> on a missing target raises this rather
+    /// than the generic Msg 208.
+    /// </summary>
+    internal static SimulatedSqlException CannotFindObjectForAlterTable(string nameAsWritten) =>
+        new($"Cannot find the object \"{nameAsWritten}\" because it does not exist or you do not have permissions.", 4902, 16, 1);
 }
diff --git a/SqlServerSimulator/Simulation/Simulation.Alter.cs b/SqlServerSimulator/Simulation/Simulation.Alter.cs
@@ -1,5 +1,6 @@
 using SqlServerSimulator.Parser;
 using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Storage;
 
 namespace SqlServerSimulator;
 
@@ -32,6 +33,8 @@ private static bool TryParseAlter(ParserContext context)
                 return TryParseAlterSequence(context);
             case ReservedKeyword { Keyword: Keyword.Schema }:
                 return TryParseAlterSchemaTransfer(context);
+            case ReservedKeyword { Keyword: Keyword.Table }:
+                return TryParseAlterTable(context);
             case ReservedKeyword { Keyword: Keyword.Database }:
                 break;
             default:
@@ -395,6 +398,85 @@ private static void TransferObject(Schema sourceSchema, Schema destSchema, strin
         throw SimulatedSqlException.CannotFindObject(leafName);
     }
 
+    /// <summary>
+    /// Parses <c>ALTER TABLE [schema.]name SET (SYSTEM_VERSIONING = OFF)</c>.
+    /// The only <c>ALTER TABLE</c> shape modeled — every other shape (ADD /
+    /// DROP COLUMN, ADD / DROP CONSTRAINT, SET other options, ENABLE /
+    /// DISABLE, REBUILD, etc.) raises <see cref="NotSupportedException"/> at
+    /// the post-name dispatch point. Entered with <see cref="ParserContext.Token"/>
+    /// on the <c>TABLE</c> keyword.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Probe-confirmed error paths (SQL Server 2025, 2026-05-13):
+    /// </para>
+    /// <list type="bullet">
+    /// <item>Target name doesn't resolve → <strong>Msg 4902</strong>
+    /// (alter-table-specific table-not-found variant; distinct from Msg 208's
+    /// generic name-resolution wording).</item>
+    /// <item>Target exists but isn't system-versioned (plain regular table
+    /// or the history sibling itself) → <strong>Msg 13591</strong>.</item>
+    /// <item>Grammar variants other than <c>SET (SYSTEM_VERSIONING = OFF)</c>
+    /// → <see cref="NotSupportedException"/>. Real SQL Server reaches a
+    /// range of error codes (Msg 102 syntax for typos, Msg 13510 for the
+    /// <c>= ON</c> path without a period definition); the simulator collapses
+    /// these to one not-supported signal since the broader ALTER TABLE
+    /// grammar isn't modeled.</item>
+    /// </list>
+    /// <para>
+    /// Successful flip clears <see cref="HeapTable.SystemVersioning"/> on the
+    /// parent (the parent's link to its history sibling) and
+    /// <see cref="HeapTable.IsHistoryTable"/> on the sibling — both tables
+    /// revert to plain regular status. Period and GENERATED ALWAYS column
+    /// metadata stays intact (probe-confirmed: <c>sys.columns.generated_always_type_desc</c>
+    /// and <c>is_hidden</c> remain after SET OFF). DROP TABLE on either now
+    /// succeeds.
+    /// </para>
+    /// </remarks>
+    private static bool TryParseAlterTable(ParserContext context)
+    {
+        context.MoveNextRequired();
+        if (context.Token is not Name)
+            return false;
+        var tableName = BatchContext.ParseObjectName(context);
+
+        // Cursor is on the last name segment; advance to the post-name token.
+        if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Set })
+            throw new NotSupportedException("Only ALTER TABLE … SET (SYSTEM_VERSIONING = OFF) is supported.");
+
+        if (context.GetNextRequired() is not Operator { Character: '(' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+
+        if (context.GetNextRequired() is not UnquotedString { ContextualKeyword: ContextualKeyword.System_Versioning })
+            throw new NotSupportedException("Only ALTER TABLE … SET (SYSTEM_VERSIONING = OFF) is supported.");
+
+        if (context.GetNextRequired() is not Operator { Character: '=' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+
+        if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Off })
+            throw new NotSupportedException("Only ALTER TABLE … SET (SYSTEM_VERSIONING = OFF) is supported (the = ON form requires the parent column-list grammar which isn't modeled).");
+
+        if (context.GetNextRequired() is not Operator { Character: ')' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+
+        if (context.Batch.IsSkipping)
+            return true;
+
+        if (!context.Batch.TryResolveTable(tableName, out var table))
+            throw SimulatedSqlException.CannotFindObjectForAlterTable(tableName.ToString());
+
+        if (table.SystemVersioning is null)
+            throw SimulatedSqlException.SystemVersioningNotOn(QualifyTableName(table, context.CurrentDatabase));
+
+        // Flip both tables to regular status. Period and GENERATED ALWAYS
+        // column metadata stays — only the parent → history link and the
+        // sibling's history-role flag clear.
+        var historyTable = table.SystemVersioning;
+        table.SystemVersioning = null;
+        historyTable.IsHistoryTable = false;
+        return true;
+    }
+
     /// <summary>
     /// Moves every trigger whose <see cref="Trigger.Parent"/> matches
     /// <paramref name="movedParent"/> from <paramref name="sourceSchema"/>'s
diff --git a/SqlServerSimulator/Simulation/Simulation.Insert.cs b/SqlServerSimulator/Simulation/Simulation.Insert.cs
@@ -358,11 +358,21 @@ private static SimulatedStatementOutcome ProcessHeapInsert(HeapTable destination
                     rowValues[i] = SqlValue.FromRowVersion(context.CurrentDatabase.AllocateRowVersion());
             }
 
-            // Auto-populate period columns on system-versioned temporal tables:
-            // ROW START = the statement's frozen UtcNow, ROW END = max
-            // datetime2 ('9999-12-31 23:59:59.9999999' — DateTime.MaxValue at
-            // datetime2(7) precision).
-            if (destinationTable.PeriodColumns is { } pc && destinationTable.SystemVersioning is not null)
+            // Auto-populate period columns whose ordinals carry the GENERATED
+            // ALWAYS markers: ROW START = the statement's frozen UtcNow, ROW
+            // END = max datetime2 ('9999-12-31 23:59:59.9999999' —
+            // DateTime.MaxValue at datetime2(7) precision). Gating on the
+            // per-column GeneratedAs (not on the table-level SystemVersioning
+            // link) matches real SQL Server's behavior probed 2026-05-13:
+            // after ALTER TABLE … SET (SYSTEM_VERSIONING = OFF), the parent's
+            // GENERATED ALWAYS column markers persist and INSERT continues to
+            // auto-populate. The (former) history sibling never reaches here:
+            // BuildHistoryTable strips the GENERATED markers, so its
+            // PeriodColumns ordinals carry GeneratedAs.None and the gate
+            // skips. (While versioning is still ON, INSERT into the history
+            // sibling is rejected upstream by Msg 13559.)
+            if (destinationTable.PeriodColumns is { } pc
+                && destinationTable.Columns[pc.StartOrdinal].GeneratedAs != GeneratedAlwaysAsRow.None)
             {
                 rowValues[pc.StartOrdinal] = SqlValue.FromDateTime2(destinationTable.Columns[pc.StartOrdinal].Type, context.Batch.CurrentStatement.UtcNow);
                 rowValues[pc.EndOrdinal] = SqlValue.FromDateTime2(destinationTable.Columns[pc.EndOrdinal].Type, DateTime.MaxValue);
diff --git a/docs/claude/temporal-tables.md b/docs/claude/temporal-tables.md
