Multi-statement TVFs (RETURNS @r TABLE (cols) AS BEGIN ... END): new MultiStatementTableValuedFunction parallel to InlineTableValuedFunction under the UserDefinedFunction base, captures parsed output columns + key/check constraints once at CREATE time (column-list parsing factored out of ParseDeclareTableVariable into shared TryParseTableVariableColumnsAndConstraints); Simulation.InvokeMultiStatementTvf allocates a child BatchContext via a new frameless body constructor (no UdfFrame / ProcFrame, so value-form RETURN N naturally surfaces Msg 178 through the existing return-statement parser), pre-seeds the @r return-table variable as a fresh per-call HeapTable in TableVariables, dispatches the body via the standard statement loop, then yields accumulated rows to the FROM-source driver. Bare RETURN; exits via the existing ReturnSignaled flag; CROSS APPLY correlation, nested TVF calls, and constraint enforcement on the return table (PK / UNIQUE / CHECK / IDENTITY) all reuse existing machinery. sys.objects.type = 'TF' and OBJECT_ID(name, 'TF') recognize the new kind. 12 new MultiStatementTvfTests + 2 EFCore tests validating EF Core 10's HasDbFunction end-to-end LINQ→SQL surface (the primary application integration point — IQueryable<T>-returning DbContext methods emit SELECT ... FROM dbo.fn(@p) which dispatches the body and projects rows back through LINQ composition). docs/claude/programmable.md gains a new section; CLAUDE.md trigger phrase extended and the deferred bullet moved to shipped.

Author: RyanLamansky

CLAUDE.md

@@ -143,7 +143,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Touching JSON_VALUE / JSON_MODIFY / OPENJSON** → [`docs/claude/json.md`](docs/claude/json.md).
 - **Changing name resolution, schema lookup, CREATE SCHEMA / DROP SCHEMA / ALTER SCHEMA TRANSFER, or OBJECT_ID** → [`docs/claude/schemas.md`](docs/claude/schemas.md).
 - **Adding or changing system metadata surfaces** (sys.* / INFORMATION_SCHEMA.*) → [`docs/claude/catalog-views.md`](docs/claude/catalog-views.md).
-- **Extending scalar UDFs, inline TVFs, views, updatable-view DML routing, stored procedures (CREATE/ALTER/DROP/EXEC), or dynamic SQL (`EXEC (@sql)` / `sp_executesql`)** → [`docs/claude/programmable.md`](docs/claude/programmable.md).
+- **Extending scalar UDFs, inline TVFs, multi-statement TVFs, views, updatable-view DML routing, stored procedures (CREATE/ALTER/DROP/EXEC), or dynamic SQL (`EXEC (@sql)` / `sp_executesql`)** → [`docs/claude/programmable.md`](docs/claude/programmable.md).
 - **Touching `#foo` routing, DROP TABLE, TRUNCATE TABLE** → [`docs/claude/temp-tables.md`](docs/claude/temp-tables.md).
 - **Touching `DECLARE @t TABLE`, table-variable DML routing, `OUTPUT … INTO <target>` (`@t` or regular)** → [`docs/claude/table-variables.md`](docs/claude/table-variables.md).
 - **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).
@@ -172,7 +172,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **CREATE SCHEMA's `<schema_element>` greedy form** — real SQL Server consumes trailing CREATE TABLE / VIEW / GRANT as part of the same CREATE SCHEMA statement (and requires CREATE SCHEMA to be the first statement in the batch as a result). The simulator instead dispatches the trailing tokens as their own statements — same end state for the common idiom, but mismatched-grammar trailers (e.g. anything that isn't a recognized statement start) raise `NotSupportedException`.
 - **`CREATE SCHEMA sys` / `INFORMATION_SCHEMA`** — raises Msg 2760 (matching real SQL Server). The schemas themselves exist as catalog-view hosts (`select * from sys.tables` / `select * from INFORMATION_SCHEMA.COLUMNS` work); legacy bare 1-part system-table access (`select * from systypes`) also still works.
 - 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`).
+- 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 (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`.

SqlServerSimulator.Tests.EFCore/EFCoreMultiStatementTvf.cs

@@ -0,0 +1,111 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end test for EF Core's <c>HasDbFunction</c> mapped to a
+/// multi-statement TVF. The DbContext registers an
+/// <see cref="IQueryable{T}"/>-returning method (<see cref="DocumentContext.OwnedBy"/>);
+/// EF Core's SqlServer provider translates the LINQ call to
+/// <c>SELECT ... FROM dbo.OwnedBy(@p)</c>, which hits the simulator's
+/// MS-TVF dispatch path end-to-end. Validates the primary EF Core
+/// integration surface for this feature.
+/// </summary>
+[TestClass]
+public sealed class EFCoreMultiStatementTvf
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private sealed class Doc
+    {
+        public int Id { get; set; }
+        public int OwnerId { get; set; }
+        public string Title { get; set; } = "";
+    }
+
+    private sealed class DocumentContext(Simulation simulation) : DbContext
+    {
+        public Simulation Simulation { get; } = simulation;
+
+        public DbSet<Doc> Docs => Set<Doc>();
+
+        public IQueryable<Doc> OwnedBy(int ownerId) =>
+            this.FromExpression(() => OwnedBy(ownerId));
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            _ = optionsBuilder.UseSqlServer(this.Simulation.CreateDbConnection());
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            _ = modelBuilder.Entity<Doc>().ToTable("Docs");
+            _ = modelBuilder.Entity<Doc>().Property(d => d.Id).ValueGeneratedNever();
+            _ = modelBuilder.Entity<Doc>().Property(d => d.Title).HasColumnType("nvarchar(50)");
+            _ = modelBuilder.HasDbFunction(
+                typeof(DocumentContext).GetMethod(nameof(OwnedBy), [typeof(int)])!)
+                .HasName("OwnedBy");
+        }
+    }
+
+    private static Simulation CreateSimulation()
+    {
+        var simulation = new Simulation();
+        var connection = simulation.CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table Docs (
+                Id int not null primary key,
+                OwnerId int not null,
+                Title nvarchar(50) not null
+            )
+            """).ExecuteNonQuery();
+        _ = connection.CreateCommand("""
+            create function dbo.OwnedBy(@oid int)
+            returns @r table (Id int not null, OwnerId int not null, Title nvarchar(50) not null)
+            as
+            begin
+                insert into @r select Id, OwnerId, Title from dbo.Docs where OwnerId = @oid;
+                return;
+            end
+            """).ExecuteNonQuery();
+        return simulation;
+    }
+
+    [TestMethod]
+    public void HasDbFunction_MapsToMultiStatementTvf()
+    {
+        using var context = new DocumentContext(CreateSimulation());
+        context.Docs.AddRange(
+            new Doc { Id = 1, OwnerId = 100, Title = "first" },
+            new Doc { Id = 2, OwnerId = 100, Title = "second" },
+            new Doc { Id = 3, OwnerId = 200, Title = "third" });
+        _ = context.SaveChanges();
+
+        var titles = context.OwnedBy(100)
+            .OrderBy(d => d.Id)
+            .Select(d => d.Title)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { "first", "second" }, titles);
+    }
+
+    [TestMethod]
+    public void HasDbFunction_FilterAndOrderTranslate()
+    {
+        // EF Core composes WHERE / ORDER BY over the TVF call client-side
+        // (TVF body returns rows, the simulator's outer SELECT applies the
+        // filter). This is the practical use case for HasDbFunction.
+        using var context = new DocumentContext(CreateSimulation());
+        context.Docs.AddRange(
+            new Doc { Id = 1, OwnerId = 100, Title = "alpha" },
+            new Doc { Id = 2, OwnerId = 100, Title = "beta" },
+            new Doc { Id = 3, OwnerId = 100, Title = "gamma" });
+        _ = context.SaveChanges();
+
+        var afterBeta = context.OwnedBy(100)
+            .Where(d => d.Title.CompareTo("beta") > 0)
+            .OrderBy(d => d.Title)
+            .Select(d => d.Title)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { "gamma" }, afterBeta);
+    }
+}