Support the "datetime" type.

Author: RyanLamansky

CLAUDE.md

@@ -71,5 +71,9 @@ Live state is best read from the code itself and recent commit history. Architec
 - Transactions / locks / MVCC: not implemented. The page foundation is in place; the next phase hasn't started.
 - Row-overflow / LOB pages: not modeled. Rows whose encoded size exceeds SQL Server's 8060-byte in-row limit throw at insert time; `varchar(MAX)` is parsed but rejected with a clear "not yet supported" error rather than silently fall through.
 - Heap allocation: flat page list. No IAM/PFS allocation tracking.
-- Cross-string-type coercion (`varchar` ↔ `nvarchar`): not modeled. The binary-expression `Promote` path's cross-category handling is also not modeled (string ↔ integer in expressions still errors). String → integer-family `CAST` is implemented, with the SQL-Server-matched Msg 244 / 245 / 248 / 8115 error variants.
+- Cross-string-type coercion (`varchar` ↔ `nvarchar`) and other cross-category pairs (string ↔ integer in binary expressions): the binary-expression `Promote` path rejects them. String → integer-family `CAST` is implemented, with the SQL-Server-matched Msg 244 / 245 / 248 / 8115 error variants. Cross-family date/time pairs in `Promote` are wired (highest-precedence-with-max-precision wins; `time` paired with non-time raises Msg 402).
+- Numeric ↔ `datetime` coercion (`cast(0 as datetime)`, `dt + 1`): not modeled. SQL Server treats integers as days-since-1900-01-01; the simulator throws `NotSupportedException` for the pair.
+- `smalldatetime`: not yet modeled. The simulator's `GetByName` rejects the type name; this is the only remaining standard date/time type EF Core may emit.
+- `ORDER BY`: not modeled. The trailing clause is consumed but not honored, so rows come back in insertion order. EF Core queries that rely on ordering need an in-memory `.OrderBy(...)` after materialization.
 - Pattern matching (`LIKE`), `CONVERT`, fixed-length `char(N)` / `nchar(N)` / `binary(N)`, and identity columns: not modeled.
+- CAST to a smaller varchar/nvarchar than the value renders: SQL Server silently truncates (e.g. `cast(dt as varchar(10))` → first 10 chars). The simulator returns the full string today; truncation isn't enforced on the CAST path.

SqlServerSimulator.Tests.EFCore/EFCoreDateTime.cs

@@ -172,4 +172,74 @@ public void Where_FiltersByDateTimeOffsetEquality_CrossOffset()
         var match = context.Events.Where(e => e.OccurredAt == west).Select(e => e.Id).Single();
         Assert.AreEqual(1, match);
     }
+
+    [TestMethod]
+    public void Insert_LegacyDateTime_RoundTripsAtTickGranularity()
+    {
+        // Legacy datetime stores 1/300-second ticks. .997 input lands on
+        // tick 299 — preserved by EF Core's reader hydration since SqlClient
+        // reconstructs DateTime ticks deterministically from the stored unit.
+        using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
+
+        var started = new DateTime(2026, 5, 4, 13, 45, 30, 997);
+        _ = context.Events.Add(new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4), Started = started });
+        _ = context.SaveChanges();
+
+        // Round-trip preserves the tick-quantized value, not the raw ms.
+        var read = context.Events.Select(e => e.Started).First();
+        Assert.IsNotNull(read);
+        Assert.AreEqual(started.Date, read.Value.Date);
+        Assert.AreEqual(started.Hour, read.Value.Hour);
+        Assert.AreEqual(started.Minute, read.Value.Minute);
+        Assert.AreEqual(started.Second, read.Value.Second);
+        // .997 ms input → tick 299 → stored at 9_966_666 100-ns ticks past the second.
+        Assert.AreEqual(9_966_666, read.Value.Ticks % TimeSpan.TicksPerSecond);
+    }
+
+    [TestMethod]
+    public void Insert_LegacyDateTime_999msRollsToNextSecond()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
+        _ = context.Events.Add(new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4), Started = new DateTime(2026, 5, 4, 13, 45, 30, 999) });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(new DateTime(2026, 5, 4, 13, 45, 31), context.Events.Select(e => e.Started).First());
+    }
+
+    [TestMethod]
+    public void Insert_NullableLegacyDateTime_AcceptsNull()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
+        _ = context.Events.Add(new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4) });
+        _ = context.SaveChanges();
+
+        Assert.IsNull(context.Events.Select(e => e.Started).First());
+        Assert.IsNull(context.Events.Select(e => e.Ended).First());
+    }
+
+    [TestMethod]
+    public void Where_FiltersByLegacyDateTimeEquality()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
+        var target = new DateTime(2026, 5, 4, 13, 45, 30);
+        context.Events.AddRange(
+            new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4), Started = new DateTime(2026, 5, 4, 12, 0, 0) },
+            new Event { Id = 2, CreatedAt = new DateTime(2026, 5, 4), Started = target },
+            new Event { Id = 3, CreatedAt = new DateTime(2026, 5, 4), Started = new DateTime(2026, 5, 4, 15, 0, 0) });
+        _ = context.SaveChanges();
+
+        var match = context.Events.Where(e => e.Started == target).Select(e => e.Id).Single();
+        Assert.AreEqual(2, match);
+    }
+
+    [TestMethod]
+    public void Insert_LegacyDateTime_AtMin_RoundTrips()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateEventsSimulation());
+        var min = new DateTime(1753, 1, 1);
+        _ = context.Events.Add(new Event { Id = 1, CreatedAt = new DateTime(2026, 5, 4), Started = min });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(min, context.Events.Select(e => e.Started).First());
+    }
 }

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -29,15 +29,13 @@ internal class Person
 }
 
 /// <summary>
-/// Exercises the simulator's <c>datetime2</c> and <c>datetimeoffset</c>
-/// column support through EF Core. The CLR-side properties stay narrow:
-/// <see cref="DateTime"/> for datetime2 and <see cref="DateTimeOffset"/>
-/// for datetimeoffset, because EF Core's SqlServer provider downcasts
-/// <see cref="System.Data.Common.DbParameter"/> to <c>SqlParameter</c> in
-/// the mappings for <see cref="DateOnly"/>, <see cref="TimeOnly"/>,
-/// <see cref="TimeSpan"/>, and <c>DateTime → date</c>. The two configurations
-/// covered here are the ones that leave the default <c>SqlDbType</c> in
-/// place and so don't trigger the downcast. See
+/// Exercises the simulator's <c>datetime</c>, <c>datetime2</c>, and
+/// <c>datetimeoffset</c> column support through EF Core. CLR-side properties
+/// are <see cref="DateTime"/> and <see cref="DateTimeOffset"/> only;
+/// <see cref="DateOnly"/>, <see cref="TimeOnly"/>, <see cref="TimeSpan"/>,
+/// and <c>DateTime → date</c> remain unreachable through EF Core's SqlServer
+/// provider because those mappings downcast
+/// <see cref="System.Data.Common.DbParameter"/> to <c>SqlParameter</c>. See
 /// <see cref="SimulatedDbParameter"/> for the full compatibility matrix.
 /// </summary>
 internal class Event
@@ -55,6 +53,17 @@ internal class Event
 
     [Column(TypeName = "datetimeoffset(3)")]
     public DateTimeOffset? Cancelled { get; set; }
+
+    /// <remarks>
+    /// Nullable to keep <see cref="DateTime"/>'s default of <c>0001-01-01</c>
+    /// from blowing up legacy <c>datetime</c>'s 1753-9999 range when the
+    /// existing event tests omit it.
+    /// </remarks>
+    [Column(TypeName = "datetime")]
+    public DateTime? Started { get; set; }
+
+    [Column(TypeName = "datetime")]
+    public DateTime? Ended { get; set; }
 }
 
 internal class TestDbContext(Simulation simulation) : DbContext
@@ -104,7 +113,14 @@ public static Simulation CreatePeopleSimulation()
         var simulation = new Simulation();
         _ = simulation
             .CreateOpenConnection()
-            .CreateCommand("create table People ( Id int, Name nvarchar(50) not null, Code varchar(10) null, Avatar varbinary(64) null )")
+            .CreateCommand("""
+                create table People (
+                    Id int,
+                    Name nvarchar(50) not null,
+                    Code varchar(10) null,
+                    Avatar varbinary(64) null
+                )
+                """)
             .ExecuteNonQuery();
         return simulation;
     }
@@ -114,7 +130,17 @@ public static Simulation CreateEventsSimulation()
         var simulation = new Simulation();
         _ = simulation
             .CreateOpenConnection()
-            .CreateCommand("create table Events ( Id int, CreatedAt datetime2(7) not null, Updated datetime2(3) null, OccurredAt datetimeoffset(7) not null, Cancelled datetimeoffset(3) null )")
+            .CreateCommand("""
+                create table Events (
+                    Id int,
+                    CreatedAt datetime2(7) not null,
+                    Updated datetime2(3) null,
+                    OccurredAt datetimeoffset(7) not null,
+                    Cancelled datetimeoffset(3) null,
+                    Started datetime null,
+                    Ended datetime null
+                )
+                """)
             .ExecuteNonQuery();
         return simulation;
     }