Added the SqlServerSimulator.EFCore adapter package, unblocking the EF Core SqlServer provider's narrowed date/time and money mappings (DateOnly/TimeOnly/TimeSpan, DateTime→date/smalldatetime, decimal→money/smallmoney).

Author: RyanLamansky

CLAUDE.md

@@ -12,7 +12,7 @@ High-fidelity SQL Server simulation, eventually including transactions, locks, M
 
 When SQL Server's actual behavior is quirky or lossy (CP1252's silent `?` replacement for out-of-codepage characters, ANSI trailing-space padding for `=`, `LEN` excluding trailing spaces), mirror it rather than "fixing" it — authenticity over desirability is what makes the simulator a faithful stand-in.
 
-The overall plan is incremental and non-specific: pick the lowest-effort path that unlocks the most useful application compatibility next. Transactions / locks / MVCC, the `varchar(MAX)` family, the EF Core adapter — all of these are eventual targets, but the order is opportunistic, driven by what's blocking the user's actual application stand-ins. Over time, this accretion gets the simulator to "most apps just work"; near term, work flows to the smallest unlock for the biggest cohort of pain points.
+The overall plan is incremental and non-specific: pick the lowest-effort path that unlocks the most useful application compatibility next. Transactions / locks / MVCC, the `varchar(MAX)` family — both are eventual targets, but the order is opportunistic, driven by what's blocking the user's actual application stand-ins. Over time, this accretion gets the simulator to "most apps just work"; near term, work flows to the smallest unlock for the biggest cohort of pain points.
 
 ## Public API surface
 
@@ -27,6 +27,8 @@ Top-level subsystems (in `SqlServerSimulator/`):
 - `Parser/` — tokenizer, expression tree, query planner
 - root — `Simulated*` implementations of `DbCommand`/`DbConnection`/`DbDataReader`/etc., plus `Simulation` itself
 
+`SqlServerSimulator.EFCore/` is a sibling package whose only public surface is `UseSqlServerSimulator(DbContextOptionsBuilder, DbConnection)`. It registers an `IRelationalTypeMappingSourcePlugin` that substitutes provider-agnostic mappings for the (CLR type, store type) pairs whose default `SqlServer`-provider mappings downcast `DbParameter` to `SqlParameter`: `DateOnly` / `DateTime → date`, `DateTime → smalldatetime`, `TimeOnly` / `TimeSpan → time(N)`, and `decimal → money` / `smallmoney`.
+
 Test projects: main feature tests, internal-access tests for storage/parser internals, EF Core integration (the oracle), and analyzer tests.
 
 ## Build, test, format
@@ -71,12 +73,12 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 
 - Transactions / locks / MVCC.
 - Row-overflow / LOB pages and the `varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` types they enable.
-- `decimal` / `numeric` values are backed by .NET `decimal`, so values requiring more than 28 significant digits aren't modeled (the type declarations up through `decimal(38, *)` are accepted so storage byte-width still matches SQL Server). `float` text formatting uses .NET's `G15`/`G7` conventions rather than SQL Server's exact `1e+015`-style scientific layout. `money` / `smallmoney` are wired in raw SQL but unreachable through EF Core for the same `SqlParameter`-downcast reason as the date-only / time-only mappings — adding a money column to an EF entity breaks that entity's whole save path.
+- `decimal` / `numeric` values are backed by .NET `decimal`, so values requiring more than 28 significant digits aren't modeled (the type declarations up through `decimal(38, *)` are accepted so storage byte-width still matches SQL Server). `float` text formatting uses .NET's `G15`/`G7` conventions rather than SQL Server's exact `1e+015`-style scientific layout.
 - `NEWSEQUENTIALID()` (deferred until `DEFAULT`-clause support exists in `CREATE TABLE`; the function is only valid in that context).
 - `CONVERT` / `TRY_CONVERT` style-code coverage. Only styles `0`, `120`, and `121` are wired up for date-like sources targeting a character string (the EF Core code-generation defaults). Other style numbers raise Msg 281; money / float / binary style codes and `CONVERT(date, str, 103)`-style date-parsing styles aren't modeled.
 - `LIKE` `COLLATE` override. The default collation (case-insensitive, Latin1_General-shaped) is what every `LIKE` runs under; explicit `COLLATE` clauses on the predicate aren't parsed yet.
 - Cross-category `Promote` for integer ↔ string. Only CAST works for that pair.
-- EF Core compatibility: the SqlServer provider downcasts `DbParameter` to `SqlParameter` for some mappings — `DateTime → date`, `DateTime → smalldatetime`, `DateOnly`, `TimeOnly`, `TimeSpan`, and `decimal → money` / `decimal → smallmoney` (via `SqlServerDecimalTypeMapping`) all break at SaveChanges. See `SimulatedDbParameter` for the matrix; a `SqlServerSimulator.EFCore` adapter package is planned to close the gap.
+- EF Core compatibility: the `SqlServerSimulator.EFCore` adapter (`UseSqlServerSimulator(...)`) covers the seven `SqlParameter`-downcast pairs — `DateOnly → date`, `DateTime → date`, `DateTime → smalldatetime`, `TimeOnly → time(N)`, `TimeSpan → time(N)`, `decimal → money`, `decimal → smallmoney`. Without the adapter (plain `UseSqlServer`), those mappings still throw at SaveChanges as before. Other type pairs the SqlServer provider supports but aren't modeled here (e.g. `hierarchyid`, `geography`, `geometry`, `rowversion`) are not bridged.
 - `OUTPUT` and `MERGE` are scoped to the EF Core SaveChanges shape: `INSERT ... OUTPUT INSERTED.<col>` (single-row) and `MERGE INTO target USING (VALUES ...) AS alias (cols) ON predicate WHEN NOT MATCHED THEN INSERT ... [OUTPUT ...]` (multi-row batch). `OUTPUT INTO @table_var`, `OUTPUT DELETED.*`, OUTPUT on UPDATE/DELETE, `INSERTED.*` star expansion, MERGE source subqueries, MERGE target with column refs in `ON`, the `WHEN MATCHED` UPDATE/DELETE branches, and `$action` aren't supported. The `WHEN MATCHED` branch parses syntactically but throws `NotSupportedException` if the per-row predicate ever evaluates true.
 - Session-scoped state. `SCOPE_IDENTITY()` / `@@IDENTITY`, `SET IDENTITY_INSERT`'s active table, and `DBCC TRACEON(N)` flags all live on `Simulation` rather than per-connection. The simulator collapses session vs global scope until a real connection-scoped state model exists; revisit when transactions/locks/MVCC bring the per-session shape with them.
 - CAST to a smaller `varchar`/`nvarchar` than the value renders: SQL Server silently truncates; the simulator returns the full string.

SqlServerSimulator.EFCore/SqlServerSimulator.EFCore.csproj

@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Title>SQL Server Simulator EF Core Adapter</Title>
+    <AssemblyTitle>SQL Server Simulator EF Core Adapter</AssemblyTitle>
+    <Authors>Ryan Lamansky</Authors>
+    <Description>EF Core adapter for SQL Server Simulator that closes the SqlServer provider's SqlParameter-downcast gaps (DateOnly, TimeOnly, TimeSpan, DateTime → date / smalldatetime, decimal → money / smallmoney).</Description>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <PackageProjectUrl>https://github.com/RyanLamansky/sql-server-simulator</PackageProjectUrl>
+    <Copyright>Copyright © Ryan Lamansky. All rights reserved.</Copyright>
+    <PackageTags>SqlServer SQL EFCore EntityFramework</PackageTags>
+    <RepositoryUrl>https://github.com/RyanLamansky/sql-server-simulator</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <DebugType>embedded</DebugType>
+    <DebugSymbols>true</DebugSymbols>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <IsTrimmable>true</IsTrimmable>
+    <AnalysisMode>All</AnalysisMode>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <RootNamespace>SqlServerSimulator.EFCore</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="../.editorconfig" Link=".editorconfig" />
+    <None Include="../LICENSE.txt" Pack="true" PackagePath="/" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="10.0.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SqlServerSimulator\SqlServerSimulator.csproj" />
+    <ProjectReference Include="..\SqlServerSimulator.Analyzers\SqlServerSimulator.Analyzers.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+  </ItemGroup>
+
+</Project>

SqlServerSimulator.EFCore/SqlServerSimulatorDbContextOptionsBuilderExtensions.cs

@@ -0,0 +1,36 @@
+using System.Data.Common;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace SqlServerSimulator.EFCore;
+
+/// <summary>
+/// Entry point for using <see cref="Simulation"/> from EF Core. Wraps
+/// <see cref="SqlServerDbContextOptionsExtensions.UseSqlServer(DbContextOptionsBuilder, DbConnection, Action{Microsoft.EntityFrameworkCore.Infrastructure.SqlServerDbContextOptionsBuilder}?)"/>
+/// and registers the simulator's type-mapping plugin so the SqlServer
+/// provider's <c>SqlParameter</c>-downcast pairs (DateOnly, TimeOnly,
+/// TimeSpan, DateTime → date / smalldatetime, decimal → money /
+/// smallmoney) succeed against a <see cref="Simulation"/>-backed
+/// connection.
+/// </summary>
+public static class SqlServerSimulatorDbContextOptionsBuilderExtensions
+{
+    /// <summary>
+    /// Configures the context to use the SqlServer provider against a
+    /// simulator-backed <see cref="DbConnection"/> and registers the
+    /// simulator's type-mapping plugin. Drop-in replacement for
+    /// <c>UseSqlServer(simulation.CreateDbConnection())</c>.
+    /// </summary>
+    /// <param name="optionsBuilder">The options builder to configure.</param>
+    /// <param name="connection">A connection from <see cref="Simulation.CreateDbConnection"/>.</param>
+    /// <returns>The same builder so calls can chain.</returns>
+    public static DbContextOptionsBuilder UseSqlServerSimulator(this DbContextOptionsBuilder optionsBuilder, DbConnection connection)
+    {
+        ArgumentNullException.ThrowIfNull(optionsBuilder);
+        _ = optionsBuilder.UseSqlServer(connection);
+
+        var extension = optionsBuilder.Options.FindExtension<SqlServerSimulatorOptionsExtension>() ?? new SqlServerSimulatorOptionsExtension();
+        ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension);
+        return optionsBuilder;
+    }
+}

SqlServerSimulator.EFCore/SqlServerSimulatorOptionsExtension.cs

@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace SqlServerSimulator.EFCore;
+
+/// <summary>
+/// Registers <see cref="SqlServerSimulatorTypeMappingSourcePlugin"/> with
+/// EF Core's relational type-mapping infrastructure when
+/// <c>UseSqlServerSimulator</c> is on the options builder. Layers on top of
+/// the standard <c>UseSqlServer</c> extension — does not replace the
+/// SqlServer provider, only its broken type-mapping cases.
+/// </summary>
+internal sealed class SqlServerSimulatorOptionsExtension : IDbContextOptionsExtension
+{
+    public DbContextOptionsExtensionInfo Info => new ExtensionInfo(this);
+
+    public void ApplyServices(IServiceCollection services) =>
+        services.AddSingleton<IRelationalTypeMappingSourcePlugin, SqlServerSimulatorTypeMappingSourcePlugin>();
+
+    public void Validate(IDbContextOptions options)
+    {
+    }
+
+    private sealed class ExtensionInfo(SqlServerSimulatorOptionsExtension extension) : DbContextOptionsExtensionInfo(extension)
+    {
+        public override bool IsDatabaseProvider => false;
+
+        public override string LogFragment => "using SqlServerSimulator type-mapping plugin ";
+
+        public override int GetServiceProviderHashCode() => 0;
+
+        public override bool ShouldUseSameServiceProvider(DbContextOptionsExtensionInfo other) => other is ExtensionInfo;
+
+        public override void PopulateDebugInfo(IDictionary<string, string> debugInfo) =>
+            debugInfo["SqlServerSimulator:TypeMappingPlugin"] = "1";
+    }
+}

SqlServerSimulator.EFCore/SqlServerSimulatorTypeMappingSourcePlugin.cs

@@ -0,0 +1,65 @@
+using System.Data;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace SqlServerSimulator.EFCore;
+
+/// <summary>
+/// Returns substitute relational type mappings for the (CLR type, store type)
+/// pairs whose default <c>SqlServer</c>-provider mappings downcast
+/// <see cref="System.Data.Common.DbParameter"/> to <c>SqlParameter</c>. Each
+/// substitute inherits from the provider-agnostic base
+/// (<see cref="DateOnlyTypeMapping"/>, <see cref="TimeOnlyTypeMapping"/>, …),
+/// which uses the default <c>ConfigureParameter</c> that simply sets
+/// <see cref="System.Data.Common.DbParameter.DbType"/> — no
+/// <c>Microsoft.Data.SqlClient</c> dependency, no failed cast.
+/// </summary>
+/// <remarks>
+/// Pairs covered:
+/// <list type="bullet">
+/// <item><see cref="DateOnly"/> → <c>date</c></item>
+/// <item><see cref="DateTime"/> → <c>date</c></item>
+/// <item><see cref="DateTime"/> → <c>smalldatetime</c></item>
+/// <item><see cref="TimeOnly"/> → <c>time</c> / <c>time(N)</c></item>
+/// <item><see cref="TimeSpan"/> → <c>time</c> / <c>time(N)</c></item>
+/// <item><see cref="decimal"/> → <c>money</c></item>
+/// <item><see cref="decimal"/> → <c>smallmoney</c></item>
+/// </list>
+/// All other mappings flow through unchanged: returning <c>null</c> from
+/// <see cref="FindMapping"/> tells EF Core to consult the next plugin or
+/// the provider's built-in mappings. The default <see cref="DateTime"/>
+/// → <c>datetime2</c> path already works under vanilla
+/// <c>UseSqlServer</c>, so it's not intercepted here.
+/// </remarks>
+[SuppressMessage("Performance", "CA1812", Justification = "Activated by EF Core's DI container via IRelationalTypeMappingSourcePlugin.")]
+internal sealed class SqlServerSimulatorTypeMappingSourcePlugin : IRelationalTypeMappingSourcePlugin
+{
+    public RelationalTypeMapping? FindMapping(in RelationalTypeMappingInfo mappingInfo)
+    {
+        var clrType = mappingInfo.ClrType;
+        var storeBase = mappingInfo.StoreTypeNameBase;
+        if (clrType is null || storeBase is null)
+            return null;
+
+        // For time(N), prefer the user-declared store name (e.g. "time(7)")
+        // so EF emits the correct DECLARE; fall back to the base name when
+        // no precision was specified.
+        var fullStoreName = mappingInfo.StoreTypeName ?? storeBase;
+
+        // money / smallmoney share DbType.Currency. Precision/scale match
+        // SQL Server's documented widths so EF migrations and any literal
+        // emitter produce the right shape; the simulator's parameter
+        // pipeline routes Currency → its Money type regardless.
+        return (clrType, storeBase) switch
+        {
+            (Type t, "date") when t == typeof(DateOnly) => new DateOnlyTypeMapping(fullStoreName, DbType.Date),
+            (Type t, "date") when t == typeof(DateTime) => new DateTimeTypeMapping(fullStoreName, DbType.Date),
+            (Type t, "smalldatetime") when t == typeof(DateTime) => new DateTimeTypeMapping(fullStoreName, DbType.DateTime),
+            (Type t, "time") when t == typeof(TimeOnly) => new TimeOnlyTypeMapping(fullStoreName, DbType.Time),
+            (Type t, "time") when t == typeof(TimeSpan) => new TimeSpanTypeMapping(fullStoreName, DbType.Time),
+            (Type t, "money") when t == typeof(decimal) => new DecimalTypeMapping(fullStoreName, DbType.Currency, precision: 19, scale: 4),
+            (Type t, "smallmoney") when t == typeof(decimal) => new DecimalTypeMapping(fullStoreName, DbType.Currency, precision: 10, scale: 4),
+            _ => null,
+        };
+    }
+}