Date-construction scalar functions: DATEFROMPARTS, DATETIMEFROMPARTS, DATETIME2FROMPARTS, DATETIMEOFFSETFROMPARTS, SMALLDATETIMEFROMPARTS, TIMEFROMPARTS, EOMONTH. Shared NULL-propagation + Msg 289 path with type-specific State numbers; precision arg constant-folded at parse time so '-1' raises Msg 1002 and NULL raises Msg 10760; EOMONTH always returns date and silently treats NULL month_offset as zero (probe-confirmed quirk).

RyanLamansky · RyanLamansky · commit 432e241f491e · 2026-05-09T17:20:17.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -258,6 +258,17 @@ String concatenation via `+` is **NULL-propagating** (matches default `CONCAT_NU
 
 `Subtract` / `Multiply` / etc. on string operands still raise `NotSupportedException` (real SQL Server: Msg 402 for `-`, Msg 8117 for `*` / `/` / `%`). Not a fidelity priority — apps don't use those shapes intentionally.
 
+### Date-construction scalar functions: the `*FROMPARTS` family + `EOMONTH`
+All six builders — `DATEFROMPARTS`, `DATETIMEFROMPARTS`, `DATETIME2FROMPARTS`, `DATETIMEOFFSETFROMPARTS`, `SMALLDATETIMEFROMPARTS`, `TIMEFROMPARTS` — share one runtime path: NULL on any non-precision argument propagates to NULL; non-int operands coerce through the existing CAST machinery (decimal / string / bigint inputs all accepted, probe-confirmed against SQL Server 2025 on 2026-05-09); out-of-range values raise **Msg 289** with the type-specific State number (1=date, 2=time, 3=datetime, 5=datetime2, 6=datetimeoffset) and verbatim text `"Cannot construct data type {type}, some of the arguments have values which are not valid."`
+
+The variable-precision builders (`datetime2` / `datetimeoffset` / `time`) accept the precision arg as the last position and require it to be an integer constant or constant expression. The simulator extracts it at parse time by evaluating the parsed sub-expression with a NULL-returning column resolver — so literal `1+2` folds to `3`, but a column reference degrades to NULL and surfaces as **Msg 10760** (`"Scale argument is not valid. Valid expressions for data type {type} scale argument are integer constants and integer constant expressions."`). Out-of-`[0, 7]` precision raises **Msg 1002** with the standard `"Specified scale {N} is invalid."` wording. Result type carries the captured precision: `DATETIME2FROMPARTS(..., 3)` → `datetime2(3)`.
+
+`DATETIMEFROMPARTS` ms 999 with hour 23 / minute 59 / second 59 rolls to the next day via legacy `datetime`'s 1/300s tick rounding (probe-confirmed). `DATETIMEOFFSETFROMPARTS` enforces sign-consistency between `hour_offset` and `minute_offset` (mixed signs raise Msg 289 State 6) and a |offset| ≤ 14:00 cap.
+
+`EOMONTH(start_date [, month_offset])` always returns `date` regardless of input type — `date` / `datetime` / `datetime2` / `datetimeoffset` / `smalldatetime` / string-literal inputs all surface as date in the output. **Quirk** worth knowing: a NULL `month_offset` is silently treated as zero (no shift), unlike NULL `start_date` which propagates. Probe-confirmed against SQL Server 2025.
+
+`DatePartsBuilder` (`Parser/Expressions/`) is a single class with a `DatePartsBuilderKind` discriminator covering all six builders; `EOMonth` lives in its own file because its argument shape (date input + optional int offset) is structurally different from the parts-list pattern.
+
 ### Constraints
 - `CHECK`: inline single-column and table-level forms; Msg 547 per row on definitely-false predicate.
 - `PRIMARY KEY` / `UNIQUE`: linear scan (O(N) per insert); no B-tree.
diff --git a/SqlServerSimulator.Tests/DatePartsBuilderTests.cs b/SqlServerSimulator.Tests/DatePartsBuilderTests.cs
@@ -0,0 +1,210 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// The six SQL Server <c>*FROMPARTS</c> date/time builders plus
+/// <c>EOMONTH</c>. Probe-anchored against SQL Server 2025 (2026-05-09).
+/// </summary>
+[TestClass]
+public sealed class DatePartsBuilderTests
+{
+    [TestMethod]
+    [DataRow("datefromparts(2026, 5, 9)", "2026-05-09")]
+    [DataRow("datefromparts(2024, 2, 29)", "2024-02-29")]
+    [DataRow("datefromparts(1, 1, 1)", "0001-01-01")]
+    [DataRow("datefromparts(9999, 12, 31)", "9999-12-31")]
+    public void DateFromParts_Valid(string expression, string expectedIso) =>
+        AreEqual(DateTime.Parse(expectedIso), ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("datefromparts(null, 5, 9)")]
+    [DataRow("datefromparts(2026, null, 9)")]
+    [DataRow("datefromparts(2026, 5, null)")]
+    public void DateFromParts_NullArgPropagates(string expression) =>
+        IsInstanceOfType<DBNull>(ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("datefromparts(2026, 13, 1)")]
+    [DataRow("datefromparts(2026, 0, 1)")]
+    [DataRow("datefromparts(2026, 2, 30)")]
+    [DataRow("datefromparts(2025, 2, 29)")]
+    [DataRow("datefromparts(0, 1, 1)")]
+    [DataRow("datefromparts(10000, 1, 1)")]
+    [DataRow("datefromparts(2026, 1, -1)")]
+    public void DateFromParts_Invalid_RaisesMsg289(string expression) =>
+        AssertSqlError($"select {expression}", 289, "Cannot construct data type date, some of the arguments have values which are not valid.");
+
+    [TestMethod]
+    [DataRow("datefromparts(2026.0, 5, 9)")]
+    [DataRow("datefromparts('2026', '5', '9')")]
+    [DataRow("datefromparts(cast(2026 as bigint), 5, 9)")]
+    public void DateFromParts_ImplicitlyCoercesArgs(string expression) =>
+        AreEqual(new DateTime(2026, 5, 9), ExecuteScalar($"select {expression}"));
+
+    /// <summary>ms=0 round-trips cleanly through datetime's 1/300s tick rounding.</summary>
+    [TestMethod]
+    public void DateTimeFromParts_Valid() =>
+        AreEqual(new DateTime(2026, 5, 9, 12, 34, 56),
+            ExecuteScalar("select datetimefromparts(2026, 5, 9, 12, 34, 56, 0)"));
+
+    [TestMethod]
+    public void DateTimeFromParts_FractionalMs_RoundsTo1_300sTick()
+    {
+        // 789 ms → rounds to the nearest 1/300s tick. Test that the result
+        // is within ~1 tick of the requested value to confirm the rounding
+        // path is used (vs. straight-passthrough).
+        var result = (DateTime)ExecuteScalar("select datetimefromparts(2026, 5, 9, 12, 34, 56, 789)")!;
+        var diff = Math.Abs((result - new DateTime(2026, 5, 9, 12, 34, 56, 789)).Ticks);
+        IsLessThan(TimeSpan.TicksPerMillisecond * 4, diff, $"datetime should round to 1/300s tick (within ~3.33 ms); got diff {diff} ticks");
+    }
+
+    /// <summary>datetime's 1/300s rounding pushes ms 999 at 23:59:59 into the next day.</summary>
+    [TestMethod]
+    public void DateTimeFromParts_Ms999Rolls() =>
+        AreEqual(new DateTime(2026, 5, 10), ExecuteScalar("select datetimefromparts(2026, 5, 9, 23, 59, 59, 999)"));
+
+    [TestMethod]
+    [DataRow("datetimefromparts(2026, 5, 9, 24, 0, 0, 0)")]
+    [DataRow("datetimefromparts(2026, 5, 9, 0, 60, 0, 0)")]
+    [DataRow("datetimefromparts(2026, 5, 9, 0, 0, 0, 1000)")]
+    public void DateTimeFromParts_Invalid_RaisesMsg289(string expression) =>
+        AssertSqlError($"select {expression}", 289, "Cannot construct data type datetime, some of the arguments have values which are not valid.");
+
+    [TestMethod]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 1234567, 7)", 7)]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 123, 3)", 3)]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 0, 0)", 0)]
+    public void DateTime2FromParts_PrecisionRespected(string expression, int precision)
+    {
+        var result = (DateTime)ExecuteScalar($"select {expression}")!;
+        AreEqual(2026, result.Year);
+        AreEqual(5, result.Month);
+        AreEqual(9, result.Day);
+        AreEqual(12, result.Hour);
+        AreEqual(34, result.Minute);
+        AreEqual(56, result.Second);
+        // Precision 7 means full 0.1234567 seconds; lower precisions store
+        // proportionally fewer fractional digits (the value is the
+        // precision-N integer multiplied to ticks).
+        var expectedTicks = precision == 0 ? 0L
+            : precision == 3 ? 123 * TimeSpan.TicksPerMillisecond
+            : 1234567L;
+        AreEqual(expectedTicks, result.Ticks % TimeSpan.TicksPerSecond);
+    }
+
+    [TestMethod]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 99999999, 7)")]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 1000, 3)")]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 1, 0)")]
+    public void DateTime2FromParts_FractionsOverflow_RaisesMsg289(string expression) =>
+        AssertSqlError($"select {expression}", 289, "Cannot construct data type datetime2, some of the arguments have values which are not valid.");
+
+    [TestMethod]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 0, 8)")]
+    [DataRow("datetime2fromparts(2026, 5, 9, 12, 34, 56, 0, -1)")]
+    public void DateTime2FromParts_PrecisionOutOfRange_RaisesMsg1002(string expression) =>
+        AssertSqlError($"select {expression}", 1002);
+
+    [TestMethod]
+    public void DateTime2FromParts_NullPrecision_RaisesMsg10760() =>
+        AssertSqlError("select datetime2fromparts(2026, 5, 9, 12, 34, 56, 0, null)", 10760,
+            "Scale argument is not valid. Valid expressions for data type datetime2 scale argument are integer constants and integer constant expressions.");
+
+    [TestMethod]
+    public void DateTime2FromParts_NullValueArg_PropagatesNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select datetime2fromparts(null, 5, 9, 12, 34, 56, 0, 7)"));
+
+    [TestMethod]
+    public void DateTimeOffsetFromParts_Standard()
+    {
+        var result = (DateTimeOffset)ExecuteScalar("select datetimeoffsetfromparts(2026, 5, 9, 12, 34, 56, 1234567, 5, 30, 7)")!;
+        AreEqual(new DateTime(2026, 5, 9, 12, 34, 56).AddTicks(1234567), result.DateTime);
+        AreEqual(TimeSpan.FromMinutes((5 * 60) + 30), result.Offset);
+    }
+
+    [TestMethod]
+    public void DateTimeOffsetFromParts_NegativeOffset_PreservesSign()
+    {
+        var result = (DateTimeOffset)ExecuteScalar("select datetimeoffsetfromparts(2026, 5, 9, 12, 34, 56, 0, -8, 0, 7)")!;
+        AreEqual(TimeSpan.FromHours(-8), result.Offset);
+    }
+
+    [TestMethod]
+    [DataRow("datetimeoffsetfromparts(2026, 5, 9, 12, 34, 56, 0, -5, 30, 7)")]
+    [DataRow("datetimeoffsetfromparts(2026, 5, 9, 12, 34, 56, 0, 15, 0, 7)")]
+    [DataRow("datetimeoffsetfromparts(2026, 5, 9, 12, 34, 56, 0, 14, 1, 7)")]
+    public void DateTimeOffsetFromParts_OffsetInvalid_RaisesMsg289(string expression) =>
+        AssertSqlError($"select {expression}", 289, "Cannot construct data type datetimeoffset, some of the arguments have values which are not valid.");
+
+    [TestMethod]
+    public void DateTimeOffsetFromParts_NullPrecision_RaisesMsg10760() =>
+        AssertSqlError("select datetimeoffsetfromparts(2026, 5, 9, 12, 34, 56, 0, 0, 0, null)", 10760,
+            "Scale argument is not valid. Valid expressions for data type datetimeoffset scale argument are integer constants and integer constant expressions.");
+
+    [TestMethod]
+    public void SmallDateTimeFromParts_Valid() =>
+        AreEqual(new DateTime(2026, 5, 9, 12, 34, 0),
+            ExecuteScalar("select smalldatetimefromparts(2026, 5, 9, 12, 34)"));
+
+    [TestMethod]
+    public void SmallDateTimeFromParts_NullArgPropagates() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select smalldatetimefromparts(null, 5, 9, 12, 34)"));
+
+    [TestMethod]
+    public void TimeFromParts_FullPrecision()
+    {
+        var span = (TimeSpan)ExecuteScalar("select timefromparts(12, 34, 56, 1234567, 7)")!;
+        AreEqual(new TimeSpan(0, 12, 34, 56) + TimeSpan.FromTicks(1234567), span);
+    }
+
+    [TestMethod]
+    public void TimeFromParts_Hour24_RaisesMsg289() =>
+        AssertSqlError("select timefromparts(24, 0, 0, 0, 0)", 289,
+            "Cannot construct data type time, some of the arguments have values which are not valid.");
+
+    [TestMethod]
+    public void TimeFromParts_NullPrecision_RaisesMsg10760() =>
+        AssertSqlError("select timefromparts(12, 34, 56, 0, null)", 10760,
+            "Scale argument is not valid. Valid expressions for data type time scale argument are integer constants and integer constant expressions.");
+
+    [TestMethod]
+    [DataRow("eomonth(cast('2026-02-15' as date))", "2026-02-28")]
+    [DataRow("eomonth(cast('2024-02-15' as date))", "2024-02-29")]
+    [DataRow("eomonth(cast('2025-02-15' as date))", "2025-02-28")]
+    [DataRow("eomonth(cast('2026-02-15' as datetime2))", "2026-02-28")]
+    [DataRow("eomonth(cast('2026-02-15T12:00:00' as datetime))", "2026-02-28")]
+    [DataRow("eomonth('2026-02-15')", "2026-02-28")]
+    [DataRow("eomonth(cast('2026-02-15' as date), 1)", "2026-03-31")]
+    [DataRow("eomonth(cast('2026-02-15' as date), -1)", "2026-01-31")]
+    [DataRow("eomonth('2026-02-15', 1)", "2026-03-31")]
+    public void EOMonth_Valid(string expression, string expectedIso) =>
+        AreEqual(DateTime.Parse(expectedIso), ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    public void EOMonth_NullStartDate_PropagatesNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select eomonth(null)"));
+
+    /// <summary>Probe-confirmed quirk: NULL <c>month_offset</c> is silently treated as 0.</summary>
+    [TestMethod]
+    public void EOMonth_NullOffset_TreatedAsZero() =>
+        AreEqual(new DateTime(2026, 2, 28),
+            ExecuteScalar("select eomonth(cast('2026-02-15' as date), null)"));
+
+    [TestMethod]
+    public void DatePartsBuilder_OfColumns_FromTable() =>
+        AreEqual(new DateTime(2026, 5, 9), new Simulation().ExecuteScalar("""
+            create table t (y int, m int, d int);
+            insert t values (2026, 5, 9);
+            select datefromparts(y, m, d) from t
+            """));
+
+    [TestMethod]
+    public void EOMonth_OfColumn_FromTable() =>
+        AreEqual(new DateTime(2026, 2, 28), new Simulation().ExecuteScalar("""
+            create table t (d date);
+            insert t values ('2026-02-15');
+            select eomonth(d) from t
+            """));
+}
diff --git a/SqlServerSimulator/Errors/SimulatedSqlException.TypeErrors.cs b/SqlServerSimulator/Errors/SimulatedSqlException.TypeErrors.cs
@@ -117,6 +117,27 @@ internal static SimulatedSqlException LengthOrPrecisionSpecificationInvalid(int
     internal static SimulatedSqlException InvalidScale(int requested, int line) =>
         new($"Line {line}: Specified scale {requested} is invalid.", 1002, 15, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 289: a <c>*FROMPARTS</c> builder received
+    /// argument values outside the legal range for the constructed type
+    /// (e.g. <c>DATEFROMPARTS(2025, 2, 30)</c>, <c>TIMEFROMPARTS(24, ...)</c>).
+    /// State numbers vary by target type: 1=date, 2=time, 3=datetime,
+    /// 5=datetime2, 6=datetimeoffset (probe-confirmed against SQL Server 2025,
+    /// 2026-05-09).
+    /// </summary>
+    internal static SimulatedSqlException CannotConstructFromParts(string typeName, byte state) =>
+        new($"Cannot construct data type {typeName}, some of the arguments have values which are not valid.", 289, 16, state);
+
+    /// <summary>
+    /// Mimics SQL Server error 10760: the scale (precision) argument of a
+    /// <c>*FROMPARTS</c> builder for <c>datetime2</c> / <c>time</c> /
+    /// <c>datetimeoffset</c> isn't a valid integer constant — typically
+    /// triggered by passing <c>NULL</c> in that slot. Probe-confirmed against
+    /// SQL Server 2025 (2026-05-09).
+    /// </summary>
+    internal static SimulatedSqlException ScaleArgumentNotValid(string typeName) =>
+        new($"Scale argument is not valid. Valid expressions for data type {typeName} scale argument are integer constants and integer constant expressions.", 10760, 16, 1);
+
     /// <summary>
     /// Mimics SQL Server error 241: a string value could not be parsed as a
     /// date or time value (e.g. <c>CAST('not-a-date' AS date)</c>). Covers
diff --git a/SqlServerSimulator/Parser/Expression.cs b/SqlServerSimulator/Parser/Expression.cs
@@ -370,6 +370,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "CEILING" => new Ceiling(context),
                 "CONVERT" => new ConvertExpression(context, tryMode: false),
                 "DATEADD" => new DateAdd(context),
+                "EOMONTH" => new EOMonth(context),
                 "GETDATE" => new CurrentTimeFunction(context, CurrentTimeKind.GetDate),
                 "REPLACE" => new Replace(context),
                 "REVERSE" => new Reverse(context),
@@ -412,7 +413,9 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             },
             13 => uppercaseName switch
             {
+                "DATEFROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.DateFromParts),
                 "IDENT_CURRENT" => new IdentCurrent(context),
+                "TIMEFROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.TimeFromParts),
                 _ => null
             },
             14 => uppercaseName switch
@@ -428,9 +431,25 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             },
             17 => uppercaseName switch
             {
+                "DATETIMEFROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.DateTimeFromParts),
                 "SYSDATETIMEOFFSET" => new CurrentTimeFunction(context, CurrentTimeKind.SysDateTimeOffset),
                 _ => null
             },
+            18 => uppercaseName switch
+            {
+                "DATETIME2FROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.DateTime2FromParts),
+                _ => null
+            },
+            22 => uppercaseName switch
+            {
+                "SMALLDATETIMEFROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.SmallDateTimeFromParts),
+                _ => null
+            },
+            23 => uppercaseName switch
+            {
+                "DATETIMEOFFSETFROMPARTS" => new DatePartsBuilder(context, DatePartsBuilderKind.DateTimeOffsetFromParts),
+                _ => null
+            },
             21 => uppercaseName switch
             {
                 "APPROX_COUNT_DISTINCT" => AggregateExpression.Parse(context, AggregateKind.ApproxCountDistinct),
diff --git a/SqlServerSimulator/Parser/Expressions/DatePartsBuilder.cs b/SqlServerSimulator/Parser/Expressions/DatePartsBuilder.cs
diff --git a/SqlServerSimulator/Parser/Expressions/EOMonth.cs b/SqlServerSimulator/Parser/Expressions/EOMonth.cs
