Support the "datetime" type, minor reorganization.

Author: RyanLamansky

CLAUDE.md

@@ -67,13 +67,15 @@ Prefer public-API tests when the behavior is reachable from SQL — they exercis
 
 ## Live limitations
 
-Live state is best read from the code itself and recent commit history. Architectural-level gaps as of the page-storage milestone:
-- 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`) 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.
+Heavy-hitters someone might assume work but don't. Source and `git log` are the truth for what's done; this list is for what isn't.
+
+- Transactions / locks / MVCC.
+- `ORDER BY` is parsed but not honored — rows come back in insertion order. EF Core queries that rely on ordering need an in-memory `.OrderBy(...)` after materialization.
+- Row-overflow / LOB pages and the `varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` types they enable.
+- Decimal / numeric / float / real / money types. (Also blocks fractional-day `cast(0.5 as datetime)`.)
+- `uniqueidentifier`, fixed-length `char(N)` / `nchar(N)` / `binary(N)`, and identity columns.
+- Pattern matching (`LIKE`) and `CONVERT`.
+- Cross-category `Promote` for `varchar` ↔ `nvarchar` and integer ↔ string. Only CAST works for those pairs.
+- EF Core compatibility: the SqlServer provider downcasts `DbParameter` to `SqlParameter` for some mappings — `DateTime → date`, `DateTime → smalldatetime`, `DateOnly`, `TimeOnly`, `TimeSpan` all break at SaveChanges. See `SimulatedDbParameter` for the matrix; a `SqlServerSimulator.EFCore` adapter package is planned to close the gap.
+- CAST to a smaller `varchar`/`nvarchar` than the value renders: SQL Server silently truncates; the simulator returns the full string.
+- Heap allocation tracking (IAM/PFS): the page list is flat.

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -33,10 +33,10 @@ internal class Person
 /// <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.
+/// <c>DateTime → date</c>, and <c>DateTime → smalldatetime</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
 {
@@ -64,6 +64,7 @@ internal class Event
 
     [Column(TypeName = "datetime")]
     public DateTime? Ended { get; set; }
+
 }
 
 internal class TestDbContext(Simulation simulation) : DbContext

SqlServerSimulator.Tests/CastTests.cs

@@ -455,4 +455,31 @@ public void Cast_InvalidScale_InLaterStatementOfBatch_FiresWhenReaderReachesIt()
         });
         AreEqual("Line 3: Specified scale 8 is invalid.", ex.Message);
     }
+
+    [TestMethod]
+    [DataRow("date")]
+    [DataRow("datetime2")]
+    [DataRow("time")]
+    [DataRow("datetimeoffset")]
+    public void Cast_IntToNonLegacyDateType_RaisesMsg529(string targetType)
+    {
+        // Only legacy datetime/smalldatetime accept integer casts; the
+        // non-legacy date types reject with Msg 529 ("Explicit conversion
+        // ... is not allowed."). The implicit-promotion counterpart raises
+        // Msg 206 — see TypePromotionTests.
+        var ex = Throws<DbException>(() => ExecuteScalar($"select cast(0 as {targetType})"));
+        AreEqual($"Explicit conversion from data type int to {targetType} is not allowed.", ex.Message);
+    }
+
+    [TestMethod]
+    [DataRow("date")]
+    [DataRow("datetime2")]
+    [DataRow("time")]
+    [DataRow("datetimeoffset")]
+    public void Cast_NonLegacyDateTypeToInt_RaisesMsg529(string sourceType)
+    {
+        var seed = sourceType == "time" ? "12:00:00" : "2024-01-15";
+        var ex = Throws<DbException>(() => ExecuteScalar($"select cast(cast('{seed}' as {sourceType}) as int)"));
+        AreEqual($"Explicit conversion from data type {sourceType} to int is not allowed.", ex.Message);
+    }
 }

SqlServerSimulator.Tests/LegacyDateTimeTests.cs

@@ -252,6 +252,171 @@ public void Equality_DifferentTicksAreUnequal()
         AreEqual(1, ids[0]);
     }
 
+    [TestMethod]
+    [DataRow("0", "1900-01-01T00:00:00")]
+    [DataRow("1", "1900-01-02T00:00:00")]
+    [DataRow("-1", "1899-12-31T00:00:00")]
+    [DataRow("-53690", "1753-01-01T00:00:00")]
+    [DataRow("2958463", "9999-12-31T00:00:00")]
+    [DataRow("45000", "2023-03-17T00:00:00")]
+    public void Cast_IntToDateTime_TreatsAsDaysSince1900(string input, string expectedIso)
+    {
+        // Legacy datetime accepts integer casts as days-since-1900-01-01.
+        var value = (DateTime)ExecuteScalar($"select cast({input} as datetime)")!;
+        AreEqual(DateTime.Parse(expectedIso, System.Globalization.CultureInfo.InvariantCulture), value);
+    }
+
+    [TestMethod]
+    public void Cast_IntToDateTime_BelowMin_RaisesMsg8115()
+    {
+        // -53691 is one day before 1753-01-01 — legacy datetime's minimum
+        // — so SQL Server raises arithmetic-overflow rather than the
+        // varchar-source Msg 242.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(-53691 as datetime)"));
+        AreEqual("Arithmetic overflow error converting expression to data type datetime.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_IntToDateTime_AboveMax_RaisesMsg8115()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(2958464 as datetime)"));
+        AreEqual("Arithmetic overflow error converting expression to data type datetime.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_BigintToDateTime_FarOutOfRange_RaisesMsg8115()
+    {
+        // Pick a value comfortably past datetime's MaxDayCount (2,958,463)
+        // that still fits in int — keeps the literal-parse path simple.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(cast(100000000 as bigint) as datetime)"));
+        AreEqual("Arithmetic overflow error converting expression to data type datetime.", ex.Message);
+    }
+
+    [TestMethod]
+    [DataRow("'1900-01-01'", 0)]
+    [DataRow("'1900-01-02'", 1)]
+    [DataRow("'1899-12-31'", -1)]
+    [DataRow("'2024-01-15'", 45304)]
+    public void Cast_DateTimeToInt_ReturnsDaysSince1900(string seed, int expectedDays) =>
+        AreEqual(expectedDays, ExecuteScalar($"select cast(cast({seed} as datetime) as int)"));
+
+    [TestMethod]
+    [DataRow("06:00:00", 0)]
+    // 11:59:59.998 quantizes to 11:59:59.997 (under half-day) → rounds down.
+    [DataRow("11:59:59.998", 0)]
+    // 11:59:59.999 quantizes to next-second tick → exactly half-day → up.
+    [DataRow("11:59:59.999", 1)]
+    [DataRow("12:00:00", 1)]
+    [DataRow("18:00:00", 1)]
+    public void Cast_DateTimeToInt_RoundsHalfAwayFromZero(string time, int expectedDays) =>
+        AreEqual(expectedDays, ExecuteScalar($"select cast(cast('1900-01-01 {time}' as datetime) as int)"));
+
+    [TestMethod]
+    public void Cast_NegativeDateTimeToInt_RoundsTowardMoreNegative()
+    {
+        // 1899-12-31 12:00:00 = -0.5 days → rounds to -1 (away from zero).
+        AreEqual(-1, ExecuteScalar("select cast(cast('1899-12-31 12:00:00' as datetime) as int)"));
+        // 1899-12-30 18:00:00 = -1.25 days → -0.25 fractional → -1 (toward zero).
+        AreEqual(-1, ExecuteScalar("select cast(cast('1899-12-30 18:00:00' as datetime) as int)"));
+    }
+
+    [TestMethod]
+    public void Cast_DateTimeToTinyint_OverflowRaisesMsg8115()
+    {
+        // Day 256 = 1900-09-14, which doesn't fit in tinyint.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(cast('1900-09-14' as datetime) as tinyint)"));
+        AreEqual("Arithmetic overflow error converting expression to data type tinyint.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_DateTimeToBit_NonZeroIsTrue()
+    {
+        AreEqual(false, ExecuteScalar("select cast(cast('1900-01-01' as datetime) as bit)"));
+        AreEqual(true, ExecuteScalar("select cast(cast('1900-01-02' as datetime) as bit)"));
+    }
+
+    [TestMethod]
+    public void Cast_BitToDateTime_ZeroAndOneAreFirstTwoDays()
+    {
+        AreEqual(new DateTime(1900, 1, 1), ExecuteScalar("select cast(cast(0 as bit) as datetime)"));
+        AreEqual(new DateTime(1900, 1, 2), ExecuteScalar("select cast(cast(1 as bit) as datetime)"));
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimePlusInt_AddsDays()
+    {
+        var value = (DateTime)ExecuteScalar("select cast('2024-01-15' as datetime) + 1")!;
+        AreEqual(new DateTime(2024, 1, 16), value);
+    }
+
+    [TestMethod]
+    public void Arithmetic_IntPlusDateTime_AddsDays()
+    {
+        var value = (DateTime)ExecuteScalar("select 1 + cast('2024-01-15' as datetime)")!;
+        AreEqual(new DateTime(2024, 1, 16), value);
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimeMinusInt_SubtractsDays()
+    {
+        var value = (DateTime)ExecuteScalar("select cast('2024-01-15' as datetime) - 1")!;
+        AreEqual(new DateTime(2024, 1, 14), value);
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimePlusInt_PreservesTimeOfDay()
+    {
+        // Adding a whole-day integer doesn't disturb the time portion.
+        var value = (DateTime)ExecuteScalar("select cast('2024-01-15 13:30:00' as datetime) + 1")!;
+        AreEqual(new DateTime(2024, 1, 16, 13, 30, 0), value);
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimePlusBigInt_StaysDateTime()
+    {
+        var value = (DateTime)ExecuteScalar("select cast('2024-01-15' as datetime) + cast(1 as bigint)")!;
+        AreEqual(new DateTime(2024, 1, 16), value);
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimePlusDateTime_SumDaysFromBase()
+    {
+        // SQL Server's legacy `dt + dt` quirk: re-interprets the sum of
+        // the two day-counts as days-since-1900-01-01. `'2024-01-15' +
+        // '2024-01-10'` lands at 90,605 days from 1900 = 2148-01-24.
+        var value = (DateTime)ExecuteScalar("select cast('2024-01-15' as datetime) + cast('2024-01-10' as datetime)")!;
+        AreEqual(new DateTime(2148, 1, 24), value);
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimeMinusDateTime_DiffDaysFromBase()
+    {
+        // `'2024-01-15' - '2024-01-10'` = 5 days → re-interpret as
+        // 5 days from 1900-01-01 = 1900-01-06.
+        var value = (DateTime)ExecuteScalar("select cast('2024-01-15' as datetime) - cast('2024-01-10' as datetime)")!;
+        AreEqual(new DateTime(1900, 1, 6), value);
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimePlus_OverflowRaisesMsg8115()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('9999-12-30' as datetime) + 100"));
+        AreEqual("Arithmetic overflow error converting expression to data type datetime.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Arithmetic_DateTimePlus_NullIntReturnsNull()
+    {
+        // DbDataReader surfaces SQL NULL as DBNull at the public boundary.
+        AreEqual(DBNull.Value, ExecuteScalar("select cast('2024-01-15' as datetime) + cast(null as int)"));
+    }
+
+    [TestMethod]
+    public void Arithmetic_NullDateTimePlusInt_ReturnsNull()
+    {
+        AreEqual(DBNull.Value, ExecuteScalar("select cast(null as datetime) + 1"));
+    }
+
     [TestMethod]
     public void Ordering_DateTimeValues_CompareByInstant()
     {