RyanLamansky
diff --git a/‎CLAUDE.md‎
Lines changed: 1 addition & 1 deletion b/‎CLAUDE.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎SqlServerSimulator.Tests/AlterTableColumnTests.cs‎
Lines changed: 372 additions & 0 deletions b/‎SqlServerSimulator.Tests/AlterTableColumnTests.cs‎
Lines changed: 372 additions & 0 deletions
@@ -178,7 +178,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.
 - 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, multi-statement TVFs (`RETURNS @r TABLE (cols) AS BEGIN ... END` — EF Core `HasDbFunction` end-to-end), 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 / ADD / DROP / CHECK / NOCHECK CONSTRAINT** — `SET (SYSTEM_VERSIONING = OFF)` (see [`docs/claude/temporal-tables.md`](docs/claude/temporal-tables.md)), `[WITH CHECK | WITH NOCHECK] ADD [CONSTRAINT name] (PRIMARY KEY | UNIQUE | FOREIGN KEY | CHECK | DEFAULT) …`, `DROP CONSTRAINT [IF EXISTS] name [, …]`, and `[WITH CHECK | WITH NOCHECK] (CHECK | NOCHECK) CONSTRAINT (ALL | name [, …])` (trust toggling for bulk imports — sets / clears `is_disabled` + `is_not_trusted`; see [`docs/claude/alter-table.md`](docs/claude/alter-table.md)) all ship. ADD / DROP COLUMN, ALTER COLUMN, DROP PERIOD FOR SYSTEM_TIME, REBUILD, SWITCH PARTITION, the SET-versioning-on direction, and every other shape raise `NotSupportedException`. Multi-constraint ADD (`ADD CONSTRAINT pk1 PK (a), CONSTRAINT fk1 FK …`) also raises.
+- **`ALTER TABLE` grammar beyond SET / ADD / DROP / CHECK / NOCHECK CONSTRAINT** — `SET (SYSTEM_VERSIONING = OFF)` (see [`docs/claude/temporal-tables.md`](docs/claude/temporal-tables.md)), `[WITH CHECK | WITH NOCHECK] ADD [CONSTRAINT name] (PRIMARY KEY | UNIQUE | FOREIGN KEY | CHECK | DEFAULT) …`, `DROP CONSTRAINT [IF EXISTS] name [, …]`, `[WITH CHECK | WITH NOCHECK] (CHECK | NOCHECK) CONSTRAINT (ALL | name [, …])` (trust toggling for bulk imports — sets / clears `is_disabled` + `is_not_trusted`), `ADD [COLUMN] col TYPE [, …]` (multi-column add — inline DEFAULT / IDENTITY / CHECK / FK / computed all supported; Msg 4901 on NOT NULL without DEFAULT on non-empty table; eager row rewrite with NULL backfill for nullable adds and constant-snapshot DEFAULT for NOT NULL), and `DROP COLUMN [IF EXISTS] col [, …]` (Msg 4924 missing column, Msg 5074 dependency rejection with multi-blocker enumeration across PK/UQ/FK/CHECK/DEFAULT/index, atomic multi-drop) all ship (see [`docs/claude/alter-table.md`](docs/claude/alter-table.md)). ALTER COLUMN, DROP PERIOD FOR SYSTEM_TIME, REBUILD, SWITCH PARTITION, the SET-versioning-on direction, and every other shape raise `NotSupportedException`. Multi-constraint ADD (`ADD CONSTRAINT pk1 PK (a), CONSTRAINT fk1 FK …`) also raises.
 - `hierarchyid`, `geography`, `geometry`.
 
 ## Quirks (modeled, not byte-identical to SQL Server)
 
@@ -0,0 +1,372 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for <c>ALTER TABLE ADD [COLUMN] col TYPE [...]</c> +
+/// <c>ALTER TABLE DROP COLUMN [IF EXISTS] col [, col...]</c>. Probed wording
+/// sourced from SQL Server 2025 on 2026-05-14.
+/// </summary>
+[TestClass]
+public sealed class AlterTableColumnTests
+{
+    // --- ADD COLUMN — basic shapes ---
+
+    [TestMethod]
+    public void AddNullableColumn_BackfillsAsNull()
+        => AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key, name nvarchar(50));
+            insert t values (1, 'a'), (2, 'b');
+            alter table t add note nvarchar(100);
+            select count(*) from t where note is null
+            """));
+
+    [TestMethod]
+    public void AddNullableColumn_WithDefault_DoesNotBackfill()
+    {
+        var sim = new Simulation();
+        // SQL Server quirk: DEFAULT on a nullable ADD only applies to
+        // future inserts; existing rows stay NULL even though the column
+        // has a DEFAULT definition.
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key);
+            insert t values (1), (2);
+            alter table t add tag int default 99
+            """);
+        AreEqual(2, sim.ExecuteScalar("select count(*) from t where tag is null"));
+        _ = sim.ExecuteNonQuery("insert t (id) values (3)");
+        AreEqual(99, sim.ExecuteScalar("select tag from t where id = 3"));
+    }
+
+    [TestMethod]
+    public void AddNotNullColumn_WithDefault_BackfillsExistingRows()
+        => AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key);
+            insert t values (1), (2);
+            alter table t add qty int not null default 0;
+            select count(*) from t where qty = 0
+            """));
+
+    [TestMethod]
+    public void AddNotNullColumn_DefaultGetUtcDate_ProducesConstantSnapshot()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key);
+            insert t values (1), (2), (3);
+            alter table t add created datetime not null default getutcdate();
+            select count(distinct created) from t
+            """));
+
+    [TestMethod]
+    public void AddNotNullColumn_WithoutDefault_OnNonEmptyTable_RaisesMsg4901()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key);
+            insert t values (1);
+            alter table t add x int not null
+            """, 4901);
+
+    [TestMethod]
+    public void AddNotNullColumn_WithoutDefault_OnEmptyTable_Succeeds()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key);
+            alter table t add x int not null;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void AddIdentityColumn_BackfillsSequential()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key);
+            insert t values (10), (20), (30);
+            alter table t add iden int identity(100, 1)
+            """);
+        AreEqual(3, sim.ExecuteScalar("select count(*) from t"));
+        AreEqual(3, sim.ExecuteScalar("select count(distinct iden) from t"));
+        AreEqual(100, sim.ExecuteScalar("select min(iden) from t"));
+        AreEqual(102, sim.ExecuteScalar("select max(iden) from t"));
+    }
+
+    [TestMethod]
+    public void AddSecondIdentityColumn_RaisesMsg2744()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key identity);
+            alter table t add iden2 int identity(1, 1)
+            """, 2744);
+
+    [TestMethod]
+    public void AddColumn_OptionalColumnKeyword_Accepted()
+        => AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key);
+            insert t values (1), (2);
+            alter table t add column note nvarchar(50);
+            select count(*) from t where note is null
+            """));
+
+    [TestMethod]
+    public void AddMultipleColumns_CommaList_AllAdded()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key);
+            insert t values (1);
+            alter table t add a int, b int default 99
+            """);
+        AreEqual(1, sim.ExecuteScalar("select count(*) from t where a is null"));
+        // Nullable with DEFAULT: existing row stays NULL.
+        AreEqual(1, sim.ExecuteScalar("select count(*) from t where b is null"));
+    }
+
+    [TestMethod]
+    public void AddColumn_DuplicateName_RaisesMsg2705()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key, name nvarchar(50));
+            alter table t add name nvarchar(100)
+            """, 2705);
+
+    [TestMethod]
+    public void AddColumn_InlineCheck_AppliedToFutureInserts()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key);
+            alter table t add qty int constraint ck_qty check (qty is null or qty > 0)
+            """);
+        _ = sim.ExecuteNonQuery("insert t values (1, 5)");
+        var ex = Throws<DbException>(() => sim.ExecuteNonQuery("insert t values (2, -5)"));
+        AreEqual("547", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void AddColumn_InlineForeignKey_Enforced()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table p (pid int not null primary key);
+            create table c (id int not null primary key);
+            insert p values (1);
+            alter table c add p_ref int constraint fk_pref references p(pid);
+            insert c values (10, 1)
+            """);
+        var ex = Throws<DbException>(() => sim.ExecuteNonQuery("insert c values (20, 999)"));
+        AreEqual("547", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void AddColumn_ComputedColumn_VisibleFromSelect()
+        => AreEqual(20, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key);
+            insert t values (10);
+            alter table t add doubled as (id * 2);
+            select doubled from t
+            """));
+
+    [TestMethod]
+    public void AddColumn_VisibleInSysColumns()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key);
+            alter table t add a int, b nvarchar(50)
+            """);
+        AreEqual(3, sim.ExecuteScalar("select count(*) from sys.columns where object_id = object_id('t')"));
+    }
+
+    // --- DROP COLUMN — basic shapes ---
+
+    [TestMethod]
+    public void DropColumn_RemovesFromTable()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, a int, b int);
+            insert t values (1, 10, 100);
+            alter table t drop column b
+            """);
+        AreEqual(2, sim.ExecuteScalar("select count(*) from sys.columns where object_id = object_id('t')"));
+        AreEqual(10, sim.ExecuteScalar("select a from t"));
+    }
+
+    [TestMethod]
+    public void DropColumn_PreservesExistingRows()
+        => AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key, name nvarchar(50));
+            insert t values (1, 'a'), (2, 'b');
+            alter table t drop column name;
+            select count(*) from t
+            """));
+
+    [TestMethod]
+    public void DropColumn_DoesNotExist_RaisesMsg4924()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key);
+            alter table t drop column missing
+            """, 4924);
+
+    [TestMethod]
+    public void DropColumn_IfExists_Missing_Silent()
+        => _ = new Simulation().ExecuteNonQuery("""
+            create table t (id int not null primary key);
+            alter table t drop column if exists missing
+            """);
+
+    [TestMethod]
+    public void DropColumn_WithDefaultConstraint_RaisesMsg5074()
+    {
+        var ex = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key, tag int default 99);
+            alter table t drop column tag
+            """, 5074);
+        Contains("dependent on column 'tag'", ex.Message);
+    }
+
+    [TestMethod]
+    public void DropColumn_WithCheckConstraint_RaisesMsg5074()
+    {
+        var ex = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key, qty int, constraint ck_q check (qty > 0));
+            alter table t drop column qty
+            """, 5074);
+        Contains("'ck_q'", ex.Message);
+    }
+
+    [TestMethod]
+    public void DropColumn_PartOfPrimaryKey_RaisesMsg5074()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key, val int);
+            alter table t drop column id
+            """, 5074);
+
+    [TestMethod]
+    public void DropColumn_ReferencedByOutgoingFk_RaisesMsg5074()
+    {
+        var ex = new Simulation().AssertSqlError("""
+            create table p (pid int not null primary key);
+            create table c (id int not null primary key, p_ref int constraint fk_p references p(pid));
+            alter table c drop column p_ref
+            """, 5074);
+        Contains("'fk_p'", ex.Message);
+    }
+
+    [TestMethod]
+    public void DropColumn_ReferencedByIncomingFk_RaisesMsg5074()
+        => _ = new Simulation().AssertSqlError("""
+            create table p (pid int not null primary key);
+            create table c (id int not null primary key, p_ref int references p(pid));
+            alter table p drop column pid
+            """, 5074);
+
+    [TestMethod]
+    public void DropColumn_WithIndexKey_RaisesMsg5074()
+    {
+        var ex = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key, a int);
+            create index ix_a on t(a);
+            alter table t drop column a
+            """, 5074);
+        Contains("The index 'ix_a'", ex.Message);
+    }
+
+    [TestMethod]
+    public void DropColumn_WithIndexInclude_RaisesMsg5074()
+    {
+        var ex = new Simulation().AssertSqlError("""
+            create table t (id int not null primary key, a int, b int);
+            create index ix_inc on t(a) include (b);
+            alter table t drop column b
+            """, 5074);
+        Contains("The index 'ix_inc'", ex.Message);
+    }
+
+    [TestMethod]
+    public void DropColumn_MultiColumn_Atomic()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, a int, b int default 99);
+            insert t values (1, 10, 100)
+            """);
+        // One blocker (b has DEFAULT) → both columns stay.
+        var ex = Throws<DbException>(() => sim.ExecuteNonQuery("alter table t drop column a, b"));
+        AreEqual("5074", ex.Data["HelpLink.EvtID"]);
+        AreEqual(3, sim.ExecuteScalar("select count(*) from sys.columns where object_id = object_id('t')"));
+    }
+
+    [TestMethod]
+    public void DropColumn_MultiColumn_AllSucceed()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, a int, b int, c int);
+            insert t values (1, 10, 100, 1000);
+            alter table t drop column a, c
+            """);
+        AreEqual(2, sim.ExecuteScalar("select count(*) from sys.columns where object_id = object_id('t')"));
+        AreEqual(100, sim.ExecuteScalar("select b from t"));
+    }
+
+    [TestMethod]
+    public void DropColumn_IdentityColumn_Succeeds()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, iden int identity(1,1));
+            insert t (id) values (10), (20);
+            alter table t drop column iden
+            """);
+        AreEqual(1, sim.ExecuteScalar("select count(*) from sys.columns where object_id = object_id('t')"));
+    }
+
+    [TestMethod]
+    public void AddThenDropColumn_RoundTripCleanlyAndPreservesRows()
+        => AreEqual(2, new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key);
+            insert t values (1), (2);
+            alter table t add note nvarchar(100);
+            alter table t drop column note;
+            select count(*) from t
+            """));
+
+    // --- Storage ordinal remapping ---
+
+    [TestMethod]
+    public void DropMiddleColumn_RemainingColumnsReadable()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, a int, b int, c int);
+            insert t values (1, 10, 100, 1000);
+            alter table t drop column b
+            """);
+        AreEqual(10, sim.ExecuteScalar("select a from t"));
+        AreEqual(1000, sim.ExecuteScalar("select c from t"));
+    }
+
+    [TestMethod]
+    public void DropMiddleColumn_PrimaryKeyStillEnforced()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, a int, b int);
+            insert t values (1, 10, 100);
+            alter table t drop column a
+            """);
+        var ex = Throws<DbException>(() => sim.ExecuteNonQuery("insert t values (1, 200)"));
+        AreEqual("2627", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void DropMiddleColumn_IndexStillFunctions()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, mid int, b int);
+            create unique index ix_b on t(b);
+            insert t values (1, 10, 100);
+            alter table t drop column mid
+            """);
+        var ex = Throws<DbException>(() => sim.ExecuteNonQuery("insert t values (2, 100)"));
+        AreEqual("2601", ex.Data["HelpLink.EvtID"]);
+    }
+}