Added DATEPART and DATEADD scalar functions covering the EF Core DateTime.Year/AddDays(N) translation patterns; both share a DatePartKind enum + helper for keyword resolution, per-input-type compatibility validation (Msg 9810), unknown-keyword rejection (Msg 155), and the DATEADD overflow path (Msg 517).

RyanLamansky · RyanLamansky · commit 3d008c53dcb8 · 2026-05-07T16:16:50.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -175,6 +175,13 @@ Top-level OFFSET/FETCH (post-set-op chain) attaches alongside the top-level ORDE
 ### Aggregates
 `COUNT(*)` / `COUNT(expr)` / `COUNT(DISTINCT expr)` / `COUNT_BIG`, `SUM` / `AVG` (integer-truncating; `decimal(38, max(s, 6))` widening for AVG over decimals), `MAX` / `MIN`, statistical (`STDEV` / `STDEVP` / `VAR` / `VARP`), `STRING_AGG`, `CHECKSUM_AGG`, `APPROX_COUNT_DISTINCT`. Standalone and inside `GROUP BY` / `HAVING`.
 
+### Date scalar functions: `DATEPART` / `DATEADD`
+Both take a bare datepart keyword as the first argument (parse-time `Name` token, not an expression). Canonical keywords + common aliases: `year`/`yy`/`yyyy`, `quarter`/`qq`/`q`, `month`/`mm`/`m`, `dayofyear`/`dy`/`y`, `day`/`dd`/`d`, `week`/`wk`/`ww`, `iso_week`/`isowk`/`isoww`, `weekday`/`dw`, `hour`/`hh`, `minute`/`mi`/`n`, `second`/`ss`/`s`, `millisecond`/`ms`, `microsecond`/`mcs`, `nanosecond`/`ns`, `tzoffset`/`tz`. `DATEPART` always returns `int`; `DATEADD` preserves the input's SQL type (`date` stays `date`, `time(N)` stays `time(N)`, etc.).
+
+Per-type keyword compatibility mirrors SQL Server (verified against Kardax7 2026-05-07): `date` accepts only date parts; `time(N)` accepts only time parts; `datetime` / `smalldatetime` / `datetime2(N)` accept date and time parts; `datetimeoffset(N)` adds `tzoffset`. Wrong combinations raise **Msg 9810** `"The datepart {part} is not supported by date function {function} for data type {type}."`. Unknown keyword → **Msg 155** `"'{X}' is not a recognized datepart option."`. `DATEADD` overflow (e.g. `dateadd(year, 100000, dateCol)`) → **Msg 517** `"Adding a value to a '{type}' column caused an overflow."`. NULL-value input → typed-NULL output (DATEPART returns NULL int). DATEPART(weekday) uses default `DATEFIRST 7` (Sunday=1, Saturday=7); changing `DATEFIRST` isn't modeled. The week / iso_week algorithm pins the default us_english behavior — week 1 is the week containing January 1, rolling on Sundays.
+
+`DatePartKind` (`Parser/Expressions/DatePartKind.cs`) is the shared enum + helpers; both `DatePart.cs` and `DateAdd.cs` route through it for keyword resolution, type-compatibility validation, extraction, and addition. `DATEDIFF` is a downstream beneficiary if/when added — same dispatch surface.
+
 ### 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 backing.
diff --git a/SqlServerSimulator.Tests.EFCore/EFCoreDateTime.cs b/SqlServerSimulator.Tests.EFCore/EFCoreDateTime.cs
@@ -242,4 +242,46 @@ public void Insert_LegacyDateTime_AtMin_RoundTrips()
 
         Assert.AreEqual(min, context.Events.Select(e => e.Started).First());
     }
+
+    [TestMethod]
+    public void Where_DateTimeYearExtraction_TranslatesToDatepart()
+    {
+        // EF Core translates .Year (and .Month / .Day / .Hour / etc.) to
+        // DATEPART(year, col). Common in real apps for "events this year"
+        // filters.
+        var simulation = TestDbContext.CreateEventsSimulation();
+        using (var seed = new TestDbContext(simulation))
+        {
+            seed.Events.AddRange(
+                new Event { Id = 1, CreatedAt = new DateTime(2023, 6, 1), OccurredAt = DateTimeOffset.MinValue },
+                new Event { Id = 2, CreatedAt = new DateTime(2024, 6, 1), OccurredAt = DateTimeOffset.MinValue },
+                new Event { Id = 3, CreatedAt = new DateTime(2024, 12, 1), OccurredAt = DateTimeOffset.MinValue });
+            _ = seed.SaveChanges();
+        }
+
+        using var context = new TestDbContext(simulation);
+        var ids = context.Events.Where(e => e.CreatedAt.Year == 2024).OrderBy(e => e.Id).Select(e => e.Id).ToArray();
+        CollectionAssert.AreEqual(new[] { 2, 3 }, ids);
+    }
+
+    [TestMethod]
+    public void Projection_DateTimeAddDays_TranslatesToDateadd()
+    {
+        // EF Core translates .AddDays(N) to DATEADD(day, CAST(N AS int), col).
+        var simulation = TestDbContext.CreateEventsSimulation();
+        using (var seed = new TestDbContext(simulation))
+        {
+            _ = seed.Events.Add(new Event
+            {
+                Id = 1,
+                CreatedAt = new DateTime(2024, 6, 1),
+                OccurredAt = DateTimeOffset.MinValue,
+            });
+            _ = seed.SaveChanges();
+        }
+
+        using var context = new TestDbContext(simulation);
+        var rolled = context.Events.Select(e => e.CreatedAt.AddDays(7)).Single();
+        Assert.AreEqual(new DateTime(2024, 6, 8), rolled);
+    }
 }
diff --git a/SqlServerSimulator.Tests/DatePartTests.cs b/SqlServerSimulator.Tests/DatePartTests.cs
@@ -0,0 +1,139 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Direct simulator coverage for the <c>DATEPART</c> and <c>DATEADD</c>
+/// scalar functions: keyword resolution (canonical + aliases), per-input-type
+/// extraction / addition semantics, NULL propagation, the cross-type
+/// compatibility rejection (Msg 9810), and the overflow path on DATEADD
+/// (Msg 517). The EF Core wire path is exercised in <c>EFCoreDateTime.cs</c>;
+/// these tests cover SQL-only edges EF Core doesn't reach.
+/// </summary>
+[TestClass]
+public sealed class DatePartTests
+{
+    [TestMethod]
+    [DataRow("year", 2024)]
+    [DataRow("month", 6)]
+    [DataRow("day", 15)]
+    [DataRow("dayofyear", 167)]
+    [DataRow("quarter", 2)]
+    [DataRow("hour", 13)]
+    [DataRow("minute", 45)]
+    [DataRow("second", 30)]
+    [DataRow("millisecond", 500)]
+    public void DatePart_OnDateTime2_ReturnsExpectedComponent(string part, int expected) =>
+        AreEqual(expected, ExecuteScalar($"select datepart({part}, cast('2024-06-15 13:45:30.5' as datetime2(7)))"));
+
+    [TestMethod]
+    [DataRow("yy", 2024)]
+    [DataRow("yyyy", 2024)]
+    [DataRow("mm", 6)]
+    [DataRow("dd", 15)]
+    [DataRow("hh", 13)]
+    [DataRow("mi", 45)]
+    [DataRow("ss", 30)]
+    public void DatePart_AcceptsCommonKeywordAliases(string alias, int expected) =>
+        AreEqual(expected, ExecuteScalar($"select datepart({alias}, cast('2024-06-15 13:45:30' as datetime2(0)))"));
+
+    [TestMethod]
+    public void DatePart_OnDate_AcceptsDateParts() =>
+        AreEqual(2024, ExecuteScalar("select datepart(year, cast('2024-06-15' as date))"));
+
+    [TestMethod]
+    public void DatePart_OnTime_AcceptsTimeParts() =>
+        AreEqual(13, ExecuteScalar("select datepart(hour, cast('13:45:30' as time))"));
+
+    [TestMethod]
+    public void DatePart_OnDateTimeOffset_AcceptsTzOffset() =>
+        AreEqual(-420, ExecuteScalar("select datepart(tzoffset, cast('2024-06-15 13:45:30 -07:00' as datetimeoffset))"));
+
+    [TestMethod]
+    public void DatePart_NullInput_ReturnsNullInt() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select datepart(year, cast(null as datetime2))"));
+
+    [TestMethod]
+    public void DatePart_UnknownKeyword_RaisesMsg155()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select datepart(badpart, getdate())"));
+        AreEqual("'badpart' is not a recognized datepart option.", ex.Message);
+        AreEqual("155", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void DatePart_HourOnDate_RaisesMsg9810()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select datepart(hour, cast('2024-06-15' as date))"));
+        AreEqual("The datepart hour is not supported by date function datepart for data type date.", ex.Message);
+        AreEqual("9810", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void DatePart_YearOnTime_RaisesMsg9810()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select datepart(year, cast('13:45:30' as time))"));
+        AreEqual("The datepart year is not supported by date function datepart for data type time.", ex.Message);
+    }
+
+    [TestMethod]
+    public void DateAdd_DayOnDate_PreservesDateType()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (d date)");
+        _ = simulation.ExecuteNonQuery("insert t values ('2024-06-15')");
+        AreEqual(new DateTime(2024, 6, 22), simulation.ExecuteScalar("select dateadd(day, 7, d) from t"));
+    }
+
+    [TestMethod]
+    public void DateAdd_HourOnTime_PreservesTimeType()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (h time(0))");
+        _ = simulation.ExecuteNonQuery("insert t values ('13:45')");
+        AreEqual(new TimeSpan(16, 45, 0), simulation.ExecuteScalar("select dateadd(hour, 3, h) from t"));
+    }
+
+    [TestMethod]
+    public void DateAdd_NegativeN_SubtractsFromValue() =>
+        AreEqual(new DateTime(2023, 6, 15), ExecuteScalar("select dateadd(year, -1, cast('2024-06-15' as datetime2(0)))"));
+
+    [TestMethod]
+    public void DateAdd_NullValue_ReturnsTypedNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select dateadd(day, 1, cast(null as datetime2))"));
+
+    [TestMethod]
+    public void DateAdd_HourOnDate_RaisesMsg9810()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select dateadd(hour, 1, cast('2024-06-15' as date))"));
+        AreEqual("The datepart hour is not supported by date function dateadd for data type date.", ex.Message);
+        AreEqual("9810", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void DateAdd_DayOnTime_RaisesMsg9810()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select dateadd(day, 1, cast('13:45' as time))"));
+        AreEqual("The datepart day is not supported by date function dateadd for data type time.", ex.Message);
+    }
+
+    [TestMethod]
+    public void DateAdd_YearOverflowOnDate_RaisesMsg517()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select dateadd(year, 100000, cast('2024-06-15' as date))"));
+        AreEqual("Adding a value to a 'date' column caused an overflow.", ex.Message);
+        AreEqual("517", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void DateAdd_TzOffsetOnDateTimeOffset_ShiftsWallClock()
+    {
+        // DATEADD(tzoffset, +60, ...) preserves the UTC instant but shifts
+        // the rendered offset by 60 minutes.
+        var v = (DateTimeOffset)ExecuteScalar("select dateadd(tzoffset, 60, cast('2024-06-15 13:00:00 +00:00' as datetimeoffset(0)))")!;
+        AreEqual(TimeSpan.FromHours(1), v.Offset);
+        AreEqual(new DateTime(2024, 6, 15, 14, 0, 0), v.DateTime);
+    }
+}
diff --git a/SqlServerSimulator/Parser/Expression.cs b/SqlServerSimulator/Parser/Expression.cs
@@ -237,13 +237,15 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             7 => uppercaseName switch
             {
                 "CONVERT" => new ConvertExpression(context, tryMode: false),
+                "DATEADD" => new DateAdd(context),
                 "REPLACE" => new Replace(context),
                 "REVERSE" => new Reverse(context),
                 _ => null
             },
             8 => uppercaseName switch
             {
                 "COALESCE" => new Coalesce(context),
+                "DATEPART" => new DatePart(context),
                 _ => null
             },
             9 => uppercaseName switch
diff --git a/SqlServerSimulator/Parser/Expressions/DateAdd.cs b/SqlServerSimulator/Parser/Expressions/DateAdd.cs
@@ -0,0 +1,48 @@
+using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>DATEADD(&lt;datepart&gt;, &lt;number&gt;, &lt;date-expr&gt;)</c>:
+/// returns the date/time value with the given count of datepart units added.
+/// The output type matches the input's (date stays date, time stays time,
+/// datetime2 stays datetime2, etc.) — matching SQL Server.
+/// </summary>
+internal sealed class DateAdd : Expression
+{
+    private readonly DatePartKind kind;
+    private readonly string keywordText;
+    private readonly Expression number;
+    private readonly Expression source;
+
+    public DateAdd(ParserContext context)
+    {
+        this.keywordText = context.Token is Name name
+            ? name.Value
+            : throw SimulatedSqlException.SyntaxErrorNear(context);
+        this.kind = DatePartKinds.ResolveOrThrow(this.keywordText);
+        if (context.GetNextRequired() is not Operator { Character: ',' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+        this.number = Parse(context.MoveNextRequiredReturnSelf());
+        if (context.Token is not Operator { Character: ',' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+        this.source = Parse(context.MoveNextRequiredReturnSelf());
+    }
+
+    public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
+    {
+        var value = source.Run(getColumnValue);
+        var n = number.Run(getColumnValue);
+        if (value.IsNull || n.IsNull)
+            return SqlValue.Null(value.Type);
+        DatePartKinds.RequireCompatible(this.kind, this.keywordText, value.Type, "dateadd");
+        var nInt = n.CoerceTo(SqlType.Int32).AsInt32;
+        return DatePartKinds.Add(this.kind, value, nInt);
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) =>
+        source.GetSqlType(resolveColumnType);
+
+    internal override string DebugDisplay() => $"DATEADD({this.keywordText}, {number.DebugDisplay()}, {source.DebugDisplay()})";
+}
diff --git a/SqlServerSimulator/Parser/Expressions/DatePart.cs b/SqlServerSimulator/Parser/Expressions/DatePart.cs
@@ -0,0 +1,48 @@
+using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>DATEPART(&lt;datepart&gt;, &lt;date-expr&gt;)</c>: extracts an integer
+/// component of the date/time value identified by the bare <c>datepart</c>
+/// keyword (year, month, day, hour, minute, second, etc.). Always returns
+/// <c>int</c>, mirroring SQL Server.
+/// </summary>
+/// <remarks>
+/// The first argument is a bare unquoted identifier — distinct from a regular
+/// expression — so the function constructor reads it as a <see cref="Name"/>
+/// and resolves it to a <see cref="DatePartKind"/> at parse time. Aliases
+/// (<c>yy</c>/<c>yyyy</c>, <c>mm</c>/<c>m</c>, <c>dd</c>/<c>d</c>, …) all
+/// resolve to the canonical kind.
+/// </remarks>
+internal sealed class DatePart : Expression
+{
+    private readonly DatePartKind kind;
+    private readonly string keywordText;
+    private readonly Expression source;
+
+    public DatePart(ParserContext context)
+    {
+        this.keywordText = context.Token is Name name
+            ? name.Value
+            : throw SimulatedSqlException.SyntaxErrorNear(context);
+        this.kind = DatePartKinds.ResolveOrThrow(this.keywordText);
+        if (context.GetNextRequired() is not Operator { Character: ',' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+        this.source = Parse(context.MoveNextRequiredReturnSelf());
+    }
+
+    public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
+    {
+        var value = source.Run(getColumnValue);
+        if (value.IsNull)
+            return SqlValue.Null(SqlType.Int32);
+        DatePartKinds.RequireCompatible(this.kind, this.keywordText, value.Type, "datepart");
+        return SqlValue.FromInt32(DatePartKinds.Extract(this.kind, value));
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+
+    internal override string DebugDisplay() => $"DATEPART({this.keywordText}, {source.DebugDisplay()})";
+}
diff --git a/SqlServerSimulator/Parser/Expressions/DatePartKind.cs b/SqlServerSimulator/Parser/Expressions/DatePartKind.cs
diff --git a/SqlServerSimulator/SimulatedSqlException.QueryErrors.cs b/SqlServerSimulator/SimulatedSqlException.QueryErrors.cs
