RyanLamansky
diff --git a/‎CLAUDE.md‎
Lines changed: 3 additions & 1 deletion b/‎CLAUDE.md‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎SqlServerSimulator.Tests.EFCore/EFCoreForeignKey.cs‎
Lines changed: 130 additions & 0 deletions b/‎SqlServerSimulator.Tests.EFCore/EFCoreForeignKey.cs‎
Lines changed: 130 additions & 0 deletions
@@ -62,7 +62,7 @@ Five scopes, one home each. **Add new state to whichever class matches its true
 
 - **`Simulation`** = server / instance. Process-shared system tables (`SystemHeapTables`), `NEWSEQUENTIALID` anchor + counter, the `Databases` dictionary. Public surface (`Simulation` ctor + `CreateDbConnection()`) stays on this class.
 - **`Database`** (internal) = one database hosted by the server instance. `Schemas` (named-schema dict, pre-seeded with `dbo`), `CompatibilityLevel`, `VerboseTruncationWarnings`, `rowVersionCounter` (per-DB `@@DBTS`). Every `Simulation` ships with one entry named `Simulation.DefaultDatabaseName` (`"simulated"`); a future `USE <db>` adds entries to the dictionary.
-- **`Schema`** (internal) = one namespace inside a database. `HeapTables` (per-schema table dict), `Functions` (UDFs — abstract `UserDefinedFunction` keyed by name, runtime-typed as either `ScalarFunction` or `InlineTableValuedFunction`), `Views` (per-schema view dict), `Procedures` (per-schema stored-procedure dict), `TableTypes` (per-schema user-defined-table-type dict — `CREATE TYPE … AS TABLE` populates; separate namespace from the object dicts, see `docs/claude/table-valued-parameters.md`), `Sequences` (per-schema sequence-object dict — `CREATE SEQUENCE` populates, shares the object namespace with tables/views/funcs/procs, see `docs/claude/sequences.md`), `Triggers` (per-schema DML-trigger dict — `CREATE TRIGGER` populates; shares the object namespace, see `docs/claude/triggers.md`). Schema-qualified references (`SELECT * FROM audit.t`, `SELECT audit.fn(x)`, `FROM audit.tvf(x)`, `FROM audit.view1`, `EXEC audit.proc1`, `DECLARE @t audit.MyType`, `NEXT VALUE FOR audit.seq`) route through `Database.Schemas["audit"]`; unqualified references fall back to `Database.DefaultSchemaName` (`"dbo"`).
+- **`Schema`** (internal) = one namespace inside a database. `HeapTables` (per-schema table dict), `Functions` (UDFs — abstract `UserDefinedFunction` keyed by name, runtime-typed as either `ScalarFunction` or `InlineTableValuedFunction`), `Views` (per-schema view dict), `Procedures` (per-schema stored-procedure dict), `TableTypes` (per-schema user-defined-table-type dict — `CREATE TYPE … AS TABLE` populates; separate namespace from the object dicts, see `docs/claude/table-valued-parameters.md`), `Sequences` (per-schema sequence-object dict — `CREATE SEQUENCE` populates, shares the object namespace with tables/views/funcs/procs, see `docs/claude/sequences.md`), `Triggers` (per-schema DML-trigger dict — `CREATE TRIGGER` populates; shares the object namespace, see `docs/claude/triggers.md`). FOREIGN KEY constraints live on `HeapTable.OutgoingForeignKeys` (child side) and `HeapTable.IncomingForeignKeys` (parent side) — see `docs/claude/foreign-keys.md`. Schema-qualified references (`SELECT * FROM audit.t`, `SELECT audit.fn(x)`, `FROM audit.tvf(x)`, `FROM audit.view1`, `EXEC audit.proc1`, `DECLARE @t audit.MyType`, `NEXT VALUE FOR audit.seq`) route through `Database.Schemas["audit"]`; unqualified references fall back to `Database.DefaultSchemaName` (`"dbo"`).
 - **`SimulatedDbConnection`** = session. `CurrentDatabase` pointer, `CurrentTransaction`, `LastIdentity` (`SCOPE_IDENTITY()` / `@@IDENTITY`), `LastStatementRowCount` (`@@ROWCOUNT`), `LastErrorNumber` (`@@ERROR`), `NestingLevel` (UDF / proc / trigger / view recursion depth, capped at 32), `IdentityInsertTable`, `TraceFlags`, `IsVerboseTruncationActive()`, `TempTables` (per-session `#foo` dictionary, cleared on `Dispose`).
 - **`BatchContext`** (internal, in `Parser/`) = one command execution. Owns the `ParserContext` (parse-time-only scratch — `Token`, `AggregateCollector`, `WindowCollector`, `OuterTypeResolver`, `CteBindings`, `InDefaultClause`, `AllowsWindowExpressions`) and holds batch-lifetime runtime state: `Variables`, `TableVariables` (per-batch `DECLARE @t TABLE`–backed `HeapTable` dict, shared namespace with scalar `Variables` for the Msg-134 uniqueness check), `CurrentUndoLog` (per-tx/per-statement, regular tables), `CurrentTableVarUndoLog` (per-statement-only, `@t` writes — kept disjoint from the tx-scoped log so `ROLLBACK TRAN` skips `@t` while statement-atomic rollback covers it), `UdfFrame` (non-null when this batch is a scalar-UDF body being dispatched — gates value-form `RETURN` and lands the return value for the caller), `ProcFrame` (non-null when this batch is a stored-procedure body — same gate for value-form `RETURN`, plus a return-code slot the caller reads), plus the per-statement frame `CurrentStatement`. Exposes `TryResolveTable(MultiPartName)` — the routing rule that dispatches `#foo` leaves to `Connection.TempTables` regardless of qualifier and `@t` leaves to `TableVariables` (1-part only — `dbo.@t` returns false; the caller raises Msg 102 at parse via `acceptTableVariable` gating); everything else routes through the named schema (or `dbo` for an unqualified reference), with `SystemHeapTables` reachable only as a flat 1-part fallback. `TryResolveFunction(MultiPartName)` resolves 2-/3-part dotted names against the named schema's `Functions` dict; 1-part names return false (real SQL Server rejects bare UDF calls with Msg 195). `TryResolveProcedure(MultiPartName)` resolves through the same schema-lookup path but accepts 1-part names (probe-confirmed: `EXEC p1` finds `dbo.p1`). `TryResolveTableType(MultiPartName)` resolves user-defined table types against the named schema's `TableTypes` dict and falls back to `dbo` for 1-part names (DECLARE @t MyType / TVP-parameter-type lookup). `TryResolveSchema(MultiPartName)` exposes the dict-bearing schema for CREATE / DROP / TRUNCATE / SELECT INTO. `ParseObjectName(ParserContext, bool acceptTableVariable = false)` parses the 1–4-segment dotted form, leaves cursor on the last name segment (standard parser contract), and compresses empty middle segments (so `tempdb..#foo` returns a 2-part name); the `acceptTableVariable` opt-in routes `@t` to a 1-part-with-`@`-prefix leaf for DML / FROM-source sites, and rejects `@t` everywhere else (so ALTER TABLE / DROP TABLE / TRUNCATE / CREATE / SELECT INTO surface Msg 102 matching probe). Threaded explicitly into every `Expression.Run(RuntimeContext runtime)` call via `runtime.Batch`. Scalar-UDF and procedure invocation each allocate a child `BatchContext` via the corresponding body constructor: parameters pre-seed `Variables`, the matching frame is set, the body source text (captured at CREATE FUNCTION / CREATE PROCEDURE time) is re-tokenized through a synthesized `SimulatedDbCommand`, and the same dispatch loop runs the body. UDF bodies discard yielded result sets at the call site (Msg 444 territory); procedure bodies forward them through to the outer caller's iterator.
 - **`StatementContext`** (internal, in `Parser/`) = the dispatch loop's per-statement frame. Allocated once per batch and overwritten in place at the top of each iteration; holds `UtcNow` (the per-statement-freeze the time scalars read). Stored-proc EXEC / TRY-CATCH frames slot in here when added.
@@ -105,6 +105,7 @@ INNER / bare JOIN / LEFT [OUTER] / RIGHT [OUTER] / FULL [OUTER] / CROSS / CROSS
 ### Constraints
 - `CHECK`: inline single-column and table-level forms; Msg 547 per row on definitely-false predicate. Inline column-level CHECK predicates may only reference their owning column — peer references raise **Msg 8141** at CREATE TABLE (probe-confirmed verbatim wording). The walker is structural via `Expression.VisitColumnReferences` + `BooleanExpression.VisitOperandExpressions`; coverage is currently limited to common container subclasses (`Reference`, `Parenthesized`, `TwoSidedExpression`, `Cast`, `Length`) — peer refs buried in less-common containers (`DATEPART`, `SUBSTRING`, nested `CASE`, etc.) silently escape the CREATE-TABLE check and surface at INSERT instead. Table-level CHECK has no peer restriction.
 - `PRIMARY KEY` / `UNIQUE`: linear scan (O(N) per insert); no B-tree.
+- `FOREIGN KEY`: inline `col REFERENCES other(col)` + table-level `FOREIGN KEY (cols) REFERENCES other(cols)` + named `CONSTRAINT name`; all four referential actions on both `ON DELETE` / `ON UPDATE` (`NO ACTION` default / `CASCADE` / `SET NULL` / `SET DEFAULT`); enforcement at INSERT / UPDATE / DELETE / MERGE; cascade-cycle rejection at CREATE (Msg 1785); referenced columns must form PK or UNIQUE (Msg 1776); NULL in FK column skips check (including partial NULL in composite); DROP TABLE on referenced parent → Msg 3726; full `sys.foreign_keys` (22 cols) + `sys.foreign_key_columns` (6 cols); `sys.objects.type = 'F '`. See `docs/claude/foreign-keys.md`.
 
 ### Transactions
 Three entry points share one per-connection undo log: implicit (statement-level atomicity), SqlClient API (`BeginTransaction()`/`Commit()`/`Rollback()`), SQL-text (`BEGIN`/`COMMIT`/`ROLLBACK`/`SAVE TRANSACTION`).
@@ -149,6 +150,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 `FOREIGN KEY` parsing (`REFERENCES` inline / `FOREIGN KEY (cols) REFERENCES other(cols)` table-level), referential-action wiring (`ON DELETE` / `ON UPDATE` × `NO ACTION` / `CASCADE` / `SET NULL` / `SET DEFAULT`), the FK enforcement loop in `Simulation.ForeignKeys.cs`, the `HeapTable.OutgoingForeignKeys` / `IncomingForeignKeys` lists, cascade-cycle detection (Msg 1785), DROP-TABLE protection (Msg 3726), or `sys.foreign_keys` / `sys.foreign_key_columns`** → [`docs/claude/foreign-keys.md`](docs/claude/foreign-keys.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).
 
 
@@ -0,0 +1,130 @@
+using Microsoft.EntityFrameworkCore;
+using SqlServerSimulator.EFCore;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end test for EF Core's relationship modeling against the simulator.
+/// <c>HasOne</c>/<c>WithMany</c> emits a FOREIGN KEY constraint in the
+/// SqlServer-flavored CREATE TABLE shape; the simulator's parser + enforcer
+/// handle it on the round-tripped SaveChanges path. Tables are bootstrapped
+/// via raw CREATE TABLE statements (EF Core's <c>EnsureCreated</c> isn't
+/// modeled — see <see cref="EFCoreHiLo"/> for the same pattern).
+/// </summary>
+[TestClass]
+public sealed class EFCoreForeignKey
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private sealed class Author
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = "";
+        public List<Book> Books { get; } = [];
+    }
+
+    private sealed class Book
+    {
+        public int Id { get; set; }
+        public string Title { get; set; } = "";
+        public int AuthorId { get; set; }
+        public Author Author { get; set; } = null!;
+    }
+
+    private sealed class LibraryContext(Simulation simulation) : DbContext
+    {
+        public Simulation Simulation { get; } = simulation;
+
+        public DbSet<Author> Authors => Set<Author>();
+        public DbSet<Book> Books => Set<Book>();
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) =>
+            optionsBuilder.UseSqlServerSimulator(this.Simulation.CreateDbConnection());
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            _ = modelBuilder.Entity<Author>(b =>
+            {
+                _ = b.Property(a => a.Name).HasColumnType("nvarchar(50)").IsRequired();
+            });
+            _ = modelBuilder.Entity<Book>(b =>
+            {
+                _ = b.Property(p => p.Title).HasColumnType("nvarchar(100)").IsRequired();
+                _ = b.HasOne(p => p.Author)
+                    .WithMany(a => a.Books)
+                    .HasForeignKey(p => p.AuthorId)
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+        }
+    }
+
+    private static Simulation CreateLibrarySimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table Authors (
+                Id int not null identity(1,1) primary key,
+                Name nvarchar(50) not null
+            );
+            create table Books (
+                Id int not null identity(1,1) primary key,
+                Title nvarchar(100) not null,
+                AuthorId int not null,
+                constraint fk_book_author foreign key (AuthorId) references Authors(Id) on delete cascade
+            )
+            """);
+        return simulation;
+    }
+
+    [TestMethod]
+    public void SaveChanges_ParentAndChild_RoundTripsThroughFkColumn()
+    {
+        using var context = new LibraryContext(CreateLibrarySimulation());
+        var author = new Author { Name = "Ada Lovelace" };
+        author.Books.Add(new Book { Title = "Notes on the Analytical Engine" });
+        author.Books.Add(new Book { Title = "Sketch of the Engine" });
+        _ = context.Authors.Add(author);
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(1, context.Authors.AsNoTracking().Count());
+        Assert.AreEqual(2, context.Books.AsNoTracking().Count());
+        Assert.AreEqual(2, context.Books.AsNoTracking().Count(b => b.AuthorId == author.Id));
+    }
+
+    [TestMethod]
+    public void SaveChanges_BookWithoutAuthor_RaisesDbUpdateException()
+    {
+        // FK violation on the child INSERT surfaces as DbUpdateException
+        // (the simulator's Msg 547 in the inner exception).
+        using var context = new LibraryContext(CreateLibrarySimulation());
+        _ = context.Books.Add(new Book { Title = "Orphan", AuthorId = 999 });
+        var ex = Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        Assert.IsNotNull(ex.InnerException);
+        Assert.Contains("FOREIGN KEY constraint", ex.InnerException.Message);
+    }
+
+    [TestMethod]
+    public void DeleteAuthor_CascadesToBooks()
+    {
+        // ON DELETE CASCADE on the FK propagates the parent delete to child
+        // rows. EF Core's client-side cascade fixup is bypassed by using
+        // raw SQL DELETE on the connection — exercising the simulator's
+        // server-side cascade engine.
+        using var context = new LibraryContext(CreateLibrarySimulation());
+        var author = new Author { Name = "Marie Curie" };
+        author.Books.Add(new Book { Title = "Recherches sur les substances radioactives" });
+        _ = context.Authors.Add(author);
+        _ = context.SaveChanges();
+        Assert.AreEqual(1, context.Books.AsNoTracking().Count());
+
+        using var connection = context.Database.GetDbConnection();
+        if (connection.State != System.Data.ConnectionState.Open)
+            connection.Open();
+        using var cmd = connection.CreateCommand();
+        cmd.CommandText = "delete from Authors";
+        _ = cmd.ExecuteNonQuery();
+
+        Assert.AreEqual(0, context.Authors.AsNoTracking().Count());
+        Assert.AreEqual(0, context.Books.AsNoTracking().Count());
+    }
+}