Explicit window frames + LAST_VALUE: new FrameSpec / FrameBound types capture ROWS BETWEEN / RANGE BETWEEN with all five bound shapes (UNBOUNDED PRECEDING / N PRECEDING / CURRENT ROW / N FOLLOWING / UNBOUNDED FOLLOWING) and the single-bound shorthand (ROWS UNBOUNDED PRECEDING ≡ ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW). Parser's RejectFrameSpec now raises Msg 10752 with the offending function name for ranking (ROW_NUMBER / RANK / DENSE_RANK / NTILE) and offset (LAG /LEAD) functions; FIRST_VALUE / LAST_VALUE / aggregate-OVER accept frames; frame without ORDER BY → Msg 10756; BETWEEN N FOLLOWING AND N PRECEDING|CURRENT ROW → Msg 4193; RANGE with numeric-offset bounds → Msg 4194 (probe-confirmed matches real SQL Server's separately-licensed-feature gate). Executor's new ComputeFrameExtent walks the no-OB-no-frame → whole partition / OB-only → default RANGE UNBOUNDED PRECEDING TO CURRENT ROW (running total with peer-tie grouping) / explicit-frame → ROWS row-precise arithmetic + RANGE CURRENT ROW peer-scan decision tree, with theoretical-then-clamp empty-frame detection (out-of-partition bounds → typed NULL for SUM/AVG/MIN/MAX/FIRST_VALUE/LAST_VALUE, 0 for COUNT). LAST_VALUE added as a new WindowKind sharing the FIRST_VALUE parse / execute paths keyed on Kind; aggregate-OVER's previous "ORDER BY → NotSupportedException" restriction lifted, with a whole-partition fast path retained when no frame applies. 27 new WindowFrameTests cover running totals (RANGE peer-ties + ROWS row-precise), sliding/expanding/whole-partition aggregates, MIN/MAX/AVG over frames, single-bound shorthand, LAST_VALUE under default (= current-row peer-tie last) vs explicit ROWS UNBOUNDED-to-UNBOUNDED (= partition last), FIRST_VALUE with explicit frame, and every rejection path (10752 across all six disallowed kinds via DataRow, 10756, 4193, 4194, 102 for invalid unbounded ends, 4112 for LAST_VALUE missing ORDER BY). WindowAggregateTests.NotSupportedShapes shrunk: ORDER-BY-in-OVER row deleted (works now), the two frame-without-ORDER-BY rows moved to WindowParserRejections asserting Msg 10756. CLAUDE.md "Not modeled" entry collapsed to RANGE-numeric-offset only; docs/claude/query.md expanded with the full frame grammar, default-frame logic, empty-frame semantics, and per-row extent execution model.

Author: RyanLamansky

CLAUDE.md

@@ -158,8 +158,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - Comma-separated FROM (legacy ANSI-89 join syntax).
 - `ANY` / `SOME` / `ALL` quantifiers.
 - Row-constructor `IN ((1,2), (3,4))`.
-- `LAST_VALUE` window function — implicit-frame semantics return the current row (or last-of-ties under RANGE), not the partition's last value; the intuitive "partition-last" form requires explicit `ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING`, which `RejectFrameSpec` rejects. Frame-spec support is the prerequisite.
-- Explicit window frames (`ROWS BETWEEN` / `RANGE BETWEEN`) — `RejectFrameSpec` raises `NotSupportedException`. The implicit defaults that ROW_NUMBER / RANK / DENSE_RANK / NTILE / LAG / LEAD / FIRST_VALUE / aggregate-OVER use natively are sufficient for EF Core's emit shape; LINQ doesn't reach any of the ranking/value functions other than ROW_NUMBER (via `Skip`/`Take`) and aggregate-OVER, so the simulator's window functions beyond ROW_NUMBER are reachable only via raw SQL.
+- `RANGE BETWEEN <N> PRECEDING` / `<N> FOLLOWING` — real SQL Server gates the numeric-offset RANGE form behind a separately-licensed feature surface and the simulator matches that rejection (Msg 4194). `ROWS` numeric-offset frames ship; both modes support the canonical `UNBOUNDED` / `CURRENT ROW` bounds and the single-bound shorthand (`ROWS UNBOUNDED PRECEDING` ≡ `ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`). The default frame when ORDER BY is present in OVER is `RANGE UNBOUNDED PRECEDING TO CURRENT ROW` (running-total semantic with peer-tie grouping); without ORDER BY, default frame is whole partition. LAST_VALUE ships with the same semantics as real SQL Server (its default frame returns the current row's value or the peer-tie last under RANGE — the intuitive "partition last" form needs explicit `ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING`).
 - Recursive-part feature restrictions (Msg 460 DISTINCT / 461 TOP / 462 OUTER JOIN / 467 aggregate-or-GROUP-BY / 465 ref-in-subquery) — silently accepted with possibly-incorrect semantics rather than raising. Apps that exercise these in real SQL Server hit rejection there too.
 - `LIKE` with `COLLATE` override (default collation only).
 - `CONVERT` / `TRY_CONVERT` style codes other than `0` / `120` / `121`.

SqlServerSimulator.Tests/WindowAggregateTests.cs

@@ -292,6 +292,10 @@ insert b values (1, 1000000000000), (1, 1000000000000)
     [DataRow("select region from sales where sum(amount) over(partition by region) > 100", 4108)]
     [DataRow("select region from sales group by region having sum(amount) over(partition by region) > 100", 4108)]
     [DataRow("select region from sales group by sum(amount) over(partition by region)", 4108)]
+    // Frame without ORDER BY → Msg 10756 (probe-confirmed). Applies to both
+    // ROWS and RANGE.
+    [DataRow("select sum(amount) over(partition by region rows between unbounded preceding and current row) from sales", 10756)]
+    [DataRow("select sum(amount) over(partition by region range between unbounded preceding and current row) from sales", 10756)]
     public void WindowParserRejections(string sql, int errorNumber)
     {
         using var connection = SeededSales();
@@ -300,9 +304,6 @@ public void WindowParserRejections(string sql, int errorNumber)
     }
 
     [TestMethod]
-    [DataRow("select sum(amount) over(partition by region order by amount) from sales")]
-    [DataRow("select sum(amount) over(partition by region rows between unbounded preceding and current row) from sales")]
-    [DataRow("select sum(amount) over(partition by region range between unbounded preceding and current row) from sales")]
     [DataRow("select region, sum(amount), sum(amount) over() from sales group by region")]
     public void NotSupportedShapes(string sql)
     {

SqlServerSimulator.Tests/WindowFrameTests.cs

@@ -302,6 +302,50 @@ internal static SimulatedSqlException FunctionNotValidForOver(string functionLow
     internal static SimulatedSqlException NTileBucketCountMustBePositive() =>
         new("The function 'NTILE' must have a positive integer value.", 9819, 16, 1);
 
+    /// <summary>
+    /// Mimics SQL Server's Msg 10752 — an explicit <c>ROWS</c> / <c>RANGE</c>
+    /// frame specification was supplied for a function that doesn't accept
+    /// one (ranking functions: <c>row_number</c> / <c>rank</c> /
+    /// <c>dense_rank</c> / <c>ntile</c>; offset functions: <c>lag</c> /
+    /// <c>lead</c>). Probe-confirmed against SQL Server 2025 (2026-05-12):
+    /// Class 15, State 1 for LAG/LEAD and State 3 for ranking; the simulator
+    /// uses State 1 uniformly (matching the LAG/LEAD probe; State 3 vs 1
+    /// isn't routed through any caller behavior).
+    /// </summary>
+    internal static SimulatedSqlException FunctionMayNotHaveWindowFrame(string functionLowerName) =>
+        new($"The function '{functionLowerName}' may not have a window frame.", 10752, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server's Msg 10756 — an explicit <c>ROWS</c> or <c>RANGE</c>
+    /// frame was supplied without an <c>ORDER BY</c> clause inside the same
+    /// <c>OVER</c>. Probe-confirmed against SQL Server 2025 (2026-05-12):
+    /// Class 15, State 1.
+    /// </summary>
+    internal static SimulatedSqlException WindowFrameRequiresOrderBy() =>
+        new("Window frame with ROWS or RANGE must have an ORDER BY clause.", 10756, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server's Msg 4193 — the frame's start bound is
+    /// <c>N FOLLOWING</c> and the end bound is <c>N PRECEDING</c> or
+    /// <c>CURRENT ROW</c>, which is semantically invalid (end before start).
+    /// Probe-confirmed against SQL Server 2025 (2026-05-12): Class 16,
+    /// State 1.
+    /// </summary>
+    internal static SimulatedSqlException FrameBetweenFollowingAndPreceding() =>
+        new("'BETWEEN ... FOLLOWING AND ... PRECEDING' is not a valid window frame and cannot be used with the OVER clause.", 4193, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server's Msg 4194 — a <c>RANGE</c> frame used a numeric-
+    /// offset bound (<c>N PRECEDING</c> / <c>N FOLLOWING</c>). Real SQL
+    /// Server restricts <c>RANGE</c> to <c>UNBOUNDED PRECEDING</c> /
+    /// <c>UNBOUNDED FOLLOWING</c> / <c>CURRENT ROW</c> (the value-based
+    /// offset form requires a separately licensed feature surface).
+    /// Probe-confirmed against SQL Server 2025 (2026-05-12): Class 16,
+    /// State 1.
+    /// </summary>
+    internal static SimulatedSqlException RangeFrameOnlySupportsUnboundedAndCurrentRow() =>
+        new("RANGE is only supported with UNBOUNDED and CURRENT ROW window frame delimiters.", 4194, 16, 1);
+
     /// <summary>
     /// Mimics SQL Server's Msg 10757 — a non-ordered-set aggregate (anything
     /// other than <c>STRING_AGG</c> in this simulator's surface) was given a

SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs

@@ -32,6 +32,7 @@ enum ContextualKeyword
     Delay,
     Encryption,
     First,
+    Following,
     Increment,
     Input,
     Log,
@@ -49,6 +50,7 @@ enum ContextualKeyword
     Output,
     Partition,
     Persisted,
+    Preceding,
     Range,
     ReadOnly,
     Recompile,
@@ -68,6 +70,7 @@ enum ContextualKeyword
     TraceOn,
     Try,
     Type,
+    Unbounded,
     Using,
     Value,
     Verbose_Truncation_Warnings,

SqlServerSimulator/Parser/ContextualKeyword.cs

@@ -527,6 +527,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "ERROR_LINE" => new ErrorLineFunction(context),
                 "GETUTCDATE" => new CurrentTimeFunction(context, CurrentTimeKind.GetUtcDate),
                 "JSON_VALUE" => new JsonValue(context),
+                "LAST_VALUE" => WindowExpression.ParseLastValue(context),
                 "ROW_NUMBER" => WindowExpression.ParseRowNumber(context),
                 "STRING_AGG" => AggregateExpression.Parse(context, AggregateKind.StringAgg),
                 _ => null

SqlServerSimulator/Parser/Expression.cs

@@ -0,0 +1,45 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Kind of a single frame boundary, used for the <c>start</c> and <c>end</c>
+/// of an explicit window frame (<c>ROWS BETWEEN &lt;start&gt; AND &lt;end&gt;</c>).
+/// </summary>
+internal enum FrameBoundKind
+{
+    UnboundedPreceding,
+    NPreceding,
+    CurrentRow,
+    NFollowing,
+    UnboundedFollowing,
+}
+
+/// <summary>
+/// A single frame boundary. <see cref="Offset"/> is meaningful only for
+/// <see cref="FrameBoundKind.NPreceding"/> / <see cref="FrameBoundKind.NFollowing"/>;
+/// it's the constant integer literal that was supplied (probed: real SQL
+/// Server requires a non-negative integer literal here — non-literal
+/// expressions raise Msg 102 at parse, negative ones Msg 1014).
+/// </summary>
+internal readonly record struct FrameBound(FrameBoundKind Kind, long Offset)
+{
+    public static readonly FrameBound UnboundedPreceding = new(FrameBoundKind.UnboundedPreceding, 0);
+    public static readonly FrameBound CurrentRow = new(FrameBoundKind.CurrentRow, 0);
+    public static readonly FrameBound UnboundedFollowing = new(FrameBoundKind.UnboundedFollowing, 0);
+    public static FrameBound NPreceding(long offset) => new(FrameBoundKind.NPreceding, offset);
+    public static FrameBound NFollowing(long offset) => new(FrameBoundKind.NFollowing, offset);
+}
+
+/// <summary>
+/// Explicit window frame (<c>ROWS BETWEEN x AND y</c> or <c>RANGE BETWEEN x AND y</c>).
+/// Captured at parse, applied per-row at execute. <see cref="IsRange"/>
+/// distinguishes RANGE (peer-tie groups share frame extents) from ROWS
+/// (each row gets its own extent by offset arithmetic).
+/// </summary>
+internal sealed class FrameSpec(bool isRange, FrameBound start, FrameBound end)
+{
+    public readonly bool IsRange = isRange;
+
+    public readonly FrameBound Start = start;
+
+    public readonly FrameBound End = end;
+}