Add TRUNCATE TABLE — clears heap rows + resets identity high-water mark; transactional via a single HeapTruncation undo entry that snapshots Pages/LobPages + each identity's high-water mark (rollback restores both — diverges from "identity bypasses log" because that rule is INSERT-only; TRUNCATE's explicit reset action does get undone, probe-confirmed). Reuses DROP TABLE's lenient multi-part name parser; Msg 4701 for missing target (distinct from DROP's 3701 and generic 208).

RyanLamansky · RyanLamansky · commit f576a5939979 · 2026-05-11T10:51:09.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -386,6 +386,11 @@ Probe-confirmed semantics (2026-05-11) the simulator handles correctly because e
 ### `WAITFOR DELAY`
 `WAITFOR DELAY '<time>'` and `WAITFOR DELAY @variable` block the calling thread via `Thread.Sleep(TimeSpan)`, matching real SQL Server's "blocks the connection" semantics. Operand grammar is strict (matches probe of SQL Server 2025, 2026-05-11): only a varchar/nvarchar string literal or an `@-variable` reference. `cast(...)`, integer literal, bare `NULL` literal all fail at parse (Msg 102/156); `time`-typed variable raises **Msg 9815** (`"Waitfor delay and waitfor time cannot be of type time."` — note SQL Server reserves the operand slot for *string-typed* values, not its own `time` type). Empty string and NULL-valued variable both silently succeed as zero delay. Bad-format string raises **Msg 148** with the offending value embedded. `@@ROWCOUNT` resets to 0. Skip-mode suppresses the sleep entirely (an `IF 1=0 WAITFOR DELAY '00:00:10'` returns instantly). **`WAITFOR TIME`** (absolute-time wait) raises `NotSupportedException` — scheduling-style primitive not yet needed. **Cancellation gap**: an `ExecuteReaderAsync` caller's `CancellationToken` isn't threaded into the sleep; the thread blocks until the duration elapses regardless.
 
+### `TRUNCATE TABLE`
+`TRUNCATE TABLE <name>` empties the heap (clears `Pages` / `LobPages`) and resets every identity column's high-water mark to its declared seed — probe-confirmed against SQL Server 2025 (2026-05-11) that a subsequent INSERT receives the seed, not the next-after-prior-max. Routing reuses the same `#`-prefix dispatch as DROP TABLE (`#foo` → connection's `TempTables`; else current DB's `HeapTables`); the lenient multi-part name parser is shared via `ParseDropTargetName`. Missing target raises **Msg 4701** (`"Cannot find the object \"X\" because it does not exist or you do not have permissions."` — note this is distinct from DROP's Msg 3701 and from generic INSERT/UPDATE/DELETE's Msg 208; TRUNCATE has its own error path). `@@ROWCOUNT` resets to 0. Skip-mode suppresses the entire action including name resolution. `WHERE` clause fails at parse (Msg 102 — TRUNCATE doesn't accept predicates).
+
+**Transactional rollback is supported** via a single `HeapTruncation` undo entry that snapshots the pre-truncate `Pages` / `LobPages` lists AND each identity column's pre-truncate high-water mark. `BEGIN TRAN; TRUNCATE; ROLLBACK` restores both — including the identity counter. **This diverges from the simulator's general "identity counters bypass the undo log" rule, which is INSERT-only**: INSERT-advanced counters stay advanced through rollback (probe-confirmed for real SQL Server too); TRUNCATE's explicit reset action gets undone on rollback. Outside an explicit transaction, TRUNCATE commits immediately (no log entry — same pattern as DROP TABLE on regular tables).
+
 ### Local temp tables (`#foo`)
 Per-connection `Dictionary<string, HeapTable> TempTables` on `SimulatedDbConnection`; routed by `BatchContext.TryResolveTable` (`#`-prefix → connection dict, else current DB + system tables). Auto-cleared on `Dispose`, matching real SQL Server's session-close drop. Lifecycle, cross-conn isolation, and Msg 208 from other sessions all probe-confirmed against SQL Server 2025.
 
@@ -425,7 +430,7 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - Compound assignment (`SET @v += expr` / `-=` / `*=` etc.) — rewrite as `SET @v = @v + expr`. The arithmetic-operator runtime is locked behind `protected` instance methods on `TwoSidedExpression`; exposing them as static helpers is the prerequisite refactor.
 - Table variables (`DECLARE @t TABLE (...)`) — separate feature with its own storage / scope / lifecycle.
 - **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.
-- **`ALTER TABLE #foo`**, **`TRUNCATE TABLE #foo`**, **`OBJECT_ID('tempdb..#foo')`** — none modeled (none of those exist for regular tables either yet). The common `IF OBJECT_ID(...) IS NOT NULL DROP TABLE` cleanup pattern works via `DROP TABLE IF EXISTS #foo` instead.
+- **`ALTER TABLE #foo`**, **`OBJECT_ID('tempdb..#foo')`** — none modeled (none of those exist for regular tables either yet). The common `IF OBJECT_ID(...) IS NOT NULL DROP TABLE` cleanup pattern works via `DROP TABLE IF EXISTS #foo` instead.
 - **Three-part name resolution outside DROP TABLE**: `tempdb..#foo` in FROM / INSERT / UPDATE / DELETE / MERGE / SET IDENTITY_INSERT raises `InvalidObjectName` (Msg 208) on the qualifier; use bare `#foo`. DROP TABLE alone tolerates the qualifier (probe pattern).
 - T-SQL `GOTO` / labels — `IF` / `BEGIN…END` / `WHILE` / `BREAK` / `CONTINUE` / `RETURN` (bare) ship; unconditional jumps don't.
 - `TRY ... CATCH`, `THROW`, `RAISERROR`, `@@ERROR`, stored procs / UDFs. `BEGIN TRY` / `BEGIN ATOMIC` / `BEGIN DISTRIBUTED TRANSACTION` raise `NotSupportedException` at dispatch (peeked after `BEGIN`). Value-form `RETURN N` raises Msg 178 (reserved for the stored-proc / function scope, neither modeled yet).
diff --git a/SqlServerSimulator.Tests/TruncateTableTests.cs b/SqlServerSimulator.Tests/TruncateTableTests.cs
@@ -0,0 +1,196 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for <c>TRUNCATE TABLE</c>: row removal, identity-counter reset,
+/// transaction rollback semantics (rollback restores both rows AND the
+/// pre-truncate identity counter — distinct from the simulator's general
+/// "identity bypasses the log" rule that applies to INSERT). Errors and
+/// skip-mode interaction. Probed against SQL Server 2025 (2026-05-11).
+/// </summary>
+[TestClass]
+public sealed class TruncateTableTests
+{
+    [TestMethod]
+    public void Truncate_RemovesAllRows()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create table t (id int);
+            insert t values (1), (2), (3);
+            truncate table t;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Truncate_ResetsIdentityToSeed()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            create table t (id int identity(1,1), v int);
+            insert t (v) values (10), (20), (30);
+            truncate table t;
+            insert t (v) values (99);
+            select id from t
+            """));
+
+    /// <summary>
+    /// Custom seed (8, 3) — first insert after TRUNCATE gets the seed (8),
+    /// not the next-after-prior-max. Probe-confirmed against SQL Server 2025.
+    /// </summary>
+    [TestMethod]
+    public void Truncate_ResetsIdentityToCustomSeed()
+        => AreEqual(8, new Simulation().ExecuteScalar("""
+            create table t (id int identity(8, 3), v int);
+            insert t (v) values (10), (20);
+            truncate table t;
+            insert t (v) values (99);
+            select id from t
+            """));
+
+    [TestMethod]
+    public void Truncate_OnEmptyTable_Succeeds()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create table t (id int);
+            truncate table t;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Truncate_OnTempTable_Works()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create table #foo (id int);
+            insert #foo values (1), (2);
+            truncate table #foo;
+            select count(*) from #foo
+            """));
+
+    [TestMethod]
+    public void Truncate_ThreePartName_Resolves()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create table t (id int);
+            insert t values (1);
+            truncate table simulated.dbo.t;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Truncate_SetsRowCountToZero()
+    {
+        using var reader = new Simulation().ExecuteReader("""
+            create table t (id int);
+            insert t values (1), (2), (3);
+            truncate table t;
+            select @@rowcount as rc
+            """);
+        IsTrue(reader.Read());
+        AreEqual(0, reader.GetInt32(0));
+    }
+
+    [TestMethod]
+    public void Truncate_NonExistentTable_Msg4701()
+        => new Simulation().AssertSqlError(
+            "truncate table does_not_exist",
+            4701,
+            "Cannot find the object \"does_not_exist\" because it does not exist or you do not have permissions.");
+
+    [TestMethod]
+    public void Truncate_NonExistentTempTable_Msg4701()
+        => new Simulation().AssertSqlError(
+            "truncate table #does_not_exist",
+            4701);
+
+    [TestMethod]
+    public void Truncate_WithWhere_SyntaxError()
+    {
+        var ex = Throws<DbException>(() => new Simulation().ExecuteNonQuery("""
+            create table t (id int);
+            truncate table t where id = 1
+            """));
+        AreEqual("102", ex.Data["HelpLink.EvtID"]);
+    }
+
+    // ---- Transaction rollback ----
+    // Probe-confirmed: ROLLBACK after TRUNCATE inside BEGIN TRAN restores
+    // both the row data AND the identity counter.
+
+    [TestMethod]
+    public void Truncate_InTransaction_RollbackRestoresRows()
+        => AreEqual(3, new Simulation().ExecuteScalar("""
+            create table t (id int);
+            insert t values (1), (2), (3);
+            begin tran;
+            truncate table t;
+            rollback;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Truncate_InTransaction_RollbackRestoresIdentity()
+    {
+        // After ROLLBACK, identity counter is back to where it was — the
+        // next INSERT after re-inserting still continues from the prior
+        // high-water mark.
+        using var reader = new Simulation().ExecuteReader("""
+            create table t (id int identity(1,1), v int);
+            insert t (v) values (10), (20), (30);
+            begin tran;
+            truncate table t;
+            rollback;
+            insert t (v) values (99);
+            select id from t order by id
+            """);
+        var ids = new List<int>();
+        while (reader.Read()) ids.Add(reader.GetInt32(0));
+        CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, ids);
+    }
+
+    [TestMethod]
+    public void Truncate_InTransaction_Commit_TruncationPersists()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create table t (id int);
+            insert t values (1), (2), (3);
+            begin tran;
+            truncate table t;
+            commit;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Truncate_InTransaction_InsertThenRollback_FullRestore()
+    {
+        // ROLLBACK undoes both the post-TRUNCATE INSERT and the TRUNCATE
+        // itself (LIFO: INSERT undo first, then TRUNCATE undo). Final state:
+        // the original three rows.
+        using var reader = new Simulation().ExecuteReader("""
+            create table t (id int);
+            insert t values (1), (2), (3);
+            begin tran;
+            truncate table t;
+            insert t values (99);
+            rollback;
+            select id from t order by id
+            """);
+        var ids = new List<int>();
+        while (reader.Read()) ids.Add(reader.GetInt32(0));
+        CollectionAssert.AreEqual(new[] { 1, 2, 3 }, ids);
+    }
+
+    // ---- Skip-mode ----
+
+    [TestMethod]
+    public void Truncate_InUntakenIf_TableUntouched()
+        => AreEqual(3, new Simulation().ExecuteScalar("""
+            create table t (id int);
+            insert t values (1), (2), (3);
+            if 1=0 truncate table t;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void Truncate_InUntakenIf_MissingTableNotChecked()
+    {
+        // Skip-mode gates the name resolution too — a TRUNCATE in an
+        // un-taken branch against a non-existent table doesn't surface
+        // Msg 4701.
+        _ = new Simulation().ExecuteNonQuery("if 1=0 truncate table does_not_exist");
+    }
+}
diff --git a/SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs b/SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs
@@ -362,4 +362,16 @@ internal static SimulatedSqlException WaitForCannotBeTimeType() =>
     /// </summary>
     internal static SimulatedSqlException InlineCheckReferencesAnotherColumn(string owningColumn, string tableName) =>
         new($"Column CHECK constraint for column '{owningColumn}' references another column, table '{tableName}'.", 8141, 16, 0);
+
+    /// <summary>
+    /// Mimics SQL Server's Msg 4701 — <c>TRUNCATE TABLE</c> against a name
+    /// that doesn't resolve to a table. Distinct from <c>DROP TABLE</c>'s
+    /// Msg 3701 and from generic INSERT/UPDATE/DELETE's Msg 208: TRUNCATE
+    /// has its own error path. Probe-confirmed against SQL Server 2025
+    /// (2026-05-11): Class 16, State 1, verbatim wording (the
+    /// <c>"or you do not have permissions"</c> suffix is part of the
+    /// real-server message and is preserved here).
+    /// </summary>
+    internal static SimulatedSqlException CannotTruncateObjectDoesNotExist(string name) =>
+        new($"Cannot find the object \"{name}\" because it does not exist or you do not have permissions.", 4701, 16, 1);
 }
diff --git a/SqlServerSimulator/Parser/Selection.cs b/SqlServerSimulator/Parser/Selection.cs
@@ -423,7 +423,7 @@ or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
                         or Keyword.Save or Keyword.Create or Keyword.Drop or Keyword.Alter or Keyword.Dbcc
                         or Keyword.Set or Keyword.Declare or Keyword.If or Keyword.Else or Keyword.End
                         or Keyword.While or Keyword.Break or Keyword.Continue or Keyword.Return
-                        or Keyword.Print or Keyword.WaitFor
+                        or Keyword.Print or Keyword.WaitFor or Keyword.Truncate
                 } when depth == 0:
                     goto ExitWhileTokenLoop;
 
@@ -567,7 +567,7 @@ or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
                         or Keyword.Save or Keyword.Create or Keyword.Drop or Keyword.Alter or Keyword.Dbcc
                         or Keyword.Set or Keyword.Declare or Keyword.If or Keyword.Else or Keyword.End
                         or Keyword.While or Keyword.Break or Keyword.Continue or Keyword.Return
-                        or Keyword.Print or Keyword.WaitFor
+                        or Keyword.Print or Keyword.WaitFor or Keyword.Truncate
                 } when depth == 0:
                     goto ExitWhileTokenLoop;
 
diff --git a/SqlServerSimulator/Simulation/Simulation.Truncate.cs b/SqlServerSimulator/Simulation/Simulation.Truncate.cs
@@ -0,0 +1,82 @@
+using SqlServerSimulator.Parser;
+using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator;
+
+partial class Simulation
+{
+    /// <summary>
+    /// Parses <c>TRUNCATE TABLE &lt;name&gt;</c>. Routes <c>#foo</c> names to
+    /// the connection's <see cref="SimulatedDbConnection.TempTables"/> dict;
+    /// everything else to <see cref="Database.HeapTables"/>. Missing target
+    /// raises <c>Msg 4701</c> — distinct from <c>DROP TABLE</c>'s Msg 3701 and
+    /// generic INSERT/UPDATE/DELETE's Msg 208.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Truncation clears every row and resets each identity column's
+    /// high-water mark to its declared seed — probe-confirmed against
+    /// SQL Server 2025 (2026-05-11) that a subsequent INSERT receives the
+    /// seed, not the next-after-the-prior-max. Distinct from the simulator's
+    /// general "identity bypasses the undo log" rule (which is INSERT-only):
+    /// TRUNCATE's reset DOES participate in rollback, so a
+    /// <c>BEGIN TRAN; TRUNCATE; ROLLBACK</c> restores both the row data and
+    /// the original identity counter — also probe-confirmed.
+    /// </para>
+    /// <para>
+    /// Rollback support uses a single <see cref="UndoLog"/> entry that
+    /// snapshots the heap's pre-truncate <see cref="Heap.Pages"/> /
+    /// <see cref="Heap.LobPages"/> lists and each identity column's
+    /// pre-truncate high-water mark. Outside an explicit transaction the
+    /// truncation commits immediately (no log entry — same pattern as
+    /// regular CREATE / DROP TABLE).
+    /// </para>
+    /// <para>
+    /// <c>@@ROWCOUNT</c> resets to 0 (probe-confirmed); skip-mode (un-taken
+    /// IF, after BREAK / CONTINUE / RETURN) suppresses the entire action.
+    /// Multi-part names (<c>tempdb..#foo</c>, <c>claude.dbo.t</c>) are
+    /// accepted via the same lenient parser <c>DROP TABLE</c> uses —
+    /// qualifier segments are cosmetic; the leaf is the routing key.
+    /// </para>
+    /// </remarks>
+    private static void ParseTruncateStatement(BatchContext batch)
+    {
+        var context = batch.Parser;
+        context.MoveNextRequired(); // consume TRUNCATE
+        if (context.Token is not ReservedKeyword { Keyword: Keyword.Table })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+        context.MoveNextRequired(); // consume TABLE
+
+        var name = ParseDropTargetName(context);
+
+        if (batch.IsSkipping)
+            return;
+
+        var isTempTable = BatchContext.IsLocalTempName(name);
+        var destination = isTempTable
+            ? context.Connection.TempTables
+            : context.CurrentDatabase.HeapTables;
+
+        if (!destination.TryGetValue(name, out var table))
+            throw SimulatedSqlException.CannotTruncateObjectDoesNotExist(name);
+
+        var oldPages = new List<HeapPage>(table.Heap.Pages);
+        var oldLobPages = new List<HeapLobPage>(table.Heap.LobPages);
+
+        var identitySnapshots = new List<(IdentityState State, long? HighWaterMark)>();
+        foreach (var column in table.Columns)
+        {
+            if (column.Identity is { } identity)
+                identitySnapshots.Add((identity, identity.Snapshot()));
+        }
+
+        table.Heap.Pages.Clear();
+        table.Heap.LobPages.Clear();
+        for (var i = 0; i < identitySnapshots.Count; i++)
+            identitySnapshots[i].State.Restore(null);
+
+        if (context.Connection.CurrentTransaction is { } tx)
+            tx.UndoLog.RecordTruncation(table.Heap, oldPages, oldLobPages, [.. identitySnapshots]);
+    }
+}
diff --git a/SqlServerSimulator/Simulation/Simulation.cs b/SqlServerSimulator/Simulation/Simulation.cs
@@ -334,6 +334,12 @@ private IEnumerable<SimulatedStatementOutcome> DispatchOneStatement(BatchContext
                     connection.LastStatementRowCount = 0;
                 break;
 
+            case ReservedKeyword { Keyword: Keyword.Truncate }:
+                ParseTruncateStatement(batch);
+                if (!batch.IsSkipping)
+                    connection.LastStatementRowCount = 0;
+                break;
+
             case ReservedKeyword { Keyword: Keyword.Begin }:
                 // Peek the token after BEGIN to disambiguate transaction-start
                 // (BEGIN TRAN / BEGIN TRANSACTION / BEGIN DISTRIBUTED TRAN) from
@@ -425,7 +431,7 @@ or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
                 or Keyword.Save or Keyword.Create or Keyword.Drop or Keyword.Alter or Keyword.Dbcc
                 or Keyword.Set or Keyword.Declare or Keyword.With or Keyword.If or Keyword.Else
                 or Keyword.End or Keyword.While or Keyword.Break or Keyword.Continue
-                or Keyword.Return or Keyword.Print or Keyword.WaitFor
+                or Keyword.Return or Keyword.Print or Keyword.WaitFor or Keyword.Truncate
         };
 
     /// <summary>
diff --git a/SqlServerSimulator/Storage/IdentityState.cs b/SqlServerSimulator/Storage/IdentityState.cs
diff --git a/SqlServerSimulator/Storage/UndoLog.cs b/SqlServerSimulator/Storage/UndoLog.cs
