Window function expansion: RANK / DENSE_RANK / NTILE / LAG / LEAD / FIRST_VALUE end-to-end. Parser dispatch in Expression.cs (6 new entries by uppercase-name-length); WindowKind enum extended with nullable Operand / OffsetArg / DefaultArg / BucketCount fields on WindowExpression; six parser methods sharing ParseNoArgRankingFunction (RANK / DENSE_RANK / ROW_NUMBER) and ParseLagLead (LAG / LEAD) backbones, all ORDER-BY-required and RejectFrameSpec-rejected. Executor in Selection.Execution.Window.cs gains a kind-keyed switch: RANK skips on ties via "prior key matches → keep prior rank, else rank = i+1"; DENSE_RANK same walk without gaps; NTILE distributes via "first count % n buckets carry one extra row" (non-positive bucket count → new Msg 9819); LAG/LEAD share sign-flipped logic, default expression evaluated in current-row resolver context, offset evaluated once per query via new EvaluateScalarArg helper; FIRST_VALUE evaluates operand at indices[0] and broadcasts. LAST_VALUE deferred — its implicit-frame semantic returns the current row, not partition-last, so a faithful implementation surprises callers; the prerequisite is explicit-frame support (own bundle). 15 new WindowFunctionTests cases cover all five families plus tie behavior, partition boundaries, and the NTILE error path. EF Core 10's DbFunctions doesn't expose any of these as extension methods — probed and confirmed — so no EFCore test added (only ROW_NUMBER reaches LINQ via Skip / Take); the new coverage helps applications using raw SQL through FromSqlInterpolated. CLAUDE.md "Not modeled" rewritten to call out LAST_VALUE + explicit frames specifically; docs/claude/query.md expanded with the ranking / value / aggregate breakdown and the EF reach note.

Author: RyanLamansky

CLAUDE.md

@@ -157,7 +157,8 @@ 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))`.
-- Window functions other than `ROW_NUMBER` and the aggregate-OVER family.
+- `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.
 - 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/WindowFunctionTests.cs

@@ -4,11 +4,15 @@
 namespace SqlServerSimulator;
 
 /// <summary>
-/// Behavioral tests for <c>ROW_NUMBER() OVER(PARTITION BY ... ORDER BY ...)</c>,
-/// the single shape EF Core 10 emits for <c>Take</c>-per-group / <c>Skip+Take</c>-per-group
-/// patterns. The function's value depends on the entire row stream
-/// (sorted within partition), so the executor buffers post-WHERE tuples
-/// before binding per-row results.
+/// Behavioral tests for ranking windows (<c>ROW_NUMBER</c> / <c>RANK</c> /
+/// <c>DENSE_RANK</c> / <c>NTILE</c>) and value windows (<c>LAG</c> /
+/// <c>LEAD</c> / <c>FIRST_VALUE</c>). All require ORDER BY inside OVER and
+/// share the post-WHERE buffer + per-partition sort path; the ranking
+/// family additionally tracks tie behavior (RANK skips, DENSE_RANK doesn't,
+/// ROW_NUMBER assigns arbitrary order within ties), and value functions
+/// re-resolve the operand against another row's tuple. <c>LAST_VALUE</c>
+/// isn't covered — its implicit-frame semantic (current row, not partition
+/// last) requires explicit-frame support which the simulator doesn't model.
 /// </summary>
 [TestClass]
 public sealed class WindowFunctionTests
@@ -158,4 +162,245 @@ public void RowNumber_CombinedWithGroupBy_NotSupported()
             _ = connection.CreateCommand(
                 "select blog_id, row_number() over(order by blog_id), count(*) from posts group by blog_id").ExecuteScalar());
     }
+
+    // === RANK / DENSE_RANK ===
+
+    /// <summary>
+    /// Seed for tie-sensitive tests: scores=10,20,20,30 in blog 1; 5,5,50 in blog 2.
+    /// </summary>
+    private static DbConnection SeededTies()
+    {
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table t (id int, grp int, v int);
+            insert t values (1, 1, 10), (2, 1, 20), (3, 1, 20), (4, 1, 30), (5, 2, 5), (6, 2, 5), (7, 2, 50)
+            """).ExecuteNonQuery();
+        return connection;
+    }
+
+    [TestMethod]
+    public void Rank_TiesShareRank_NextRankSkipsAhead()
+    {
+        // RANK with ties: 10 → 1, 20 (tie) → 2, 20 (tie) → 2, 30 → 4 (skips 3).
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, rank() over(order by v) from t where grp = 1").ExecuteReader();
+        var byId = new Dictionary<int, long>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt64(1);
+        AreEqual(1L, byId[1]);
+        AreEqual(2L, byId[2]);
+        AreEqual(2L, byId[3]);
+        AreEqual(4L, byId[4]);
+    }
+
+    [TestMethod]
+    public void DenseRank_TiesShareRank_NextRankDoesNotSkip()
+    {
+        // DENSE_RANK with ties: 10 → 1, 20 (tie) → 2, 20 (tie) → 2, 30 → 3 (no gap).
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, dense_rank() over(order by v) from t where grp = 1").ExecuteReader();
+        var byId = new Dictionary<int, long>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt64(1);
+        AreEqual(1L, byId[1]);
+        AreEqual(2L, byId[2]);
+        AreEqual(2L, byId[3]);
+        AreEqual(3L, byId[4]);
+    }
+
+    [TestMethod]
+    public void Rank_PartitionedResetsPerPartition()
+    {
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, rank() over(partition by grp order by v) from t").ExecuteReader();
+        var byId = new Dictionary<int, long>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt64(1);
+        // Group 1: 1→1, 2→2, 3→2, 4→4. Group 2: 5→1, 6→1, 7→3.
+        AreEqual(1L, byId[5]);
+        AreEqual(1L, byId[6]);
+        AreEqual(3L, byId[7]);
+    }
+
+    [TestMethod]
+    public void Rank_RequiresOrderByInsideOver()
+    {
+        using var connection = SeededTies();
+        _ = Throws<DbException>(() =>
+            _ = connection.CreateCommand("select rank() over() from t").ExecuteScalar());
+    }
+
+    // === NTILE ===
+
+    [TestMethod]
+    public void NTile_DistributesRowsEvenly()
+    {
+        // 6 rows / 3 buckets = 2 rows per bucket.
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, ntile(3) over(order by id) from t where id <= 6").ExecuteReader();
+        var byId = new Dictionary<int, int>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt32(1);
+        AreEqual(1, byId[1]);
+        AreEqual(1, byId[2]);
+        AreEqual(2, byId[3]);
+        AreEqual(2, byId[4]);
+        AreEqual(3, byId[5]);
+        AreEqual(3, byId[6]);
+    }
+
+    [TestMethod]
+    public void NTile_UnevenDistribution_FirstBucketsLarger()
+    {
+        // 7 rows / 3 buckets → smaller=2, remainder=1 → first bucket has 3, rest have 2.
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, ntile(3) over(order by id) from t").ExecuteReader();
+        var byId = new Dictionary<int, int>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt32(1);
+        // Bucket sizes: [3, 2, 2] → IDs 1,2,3 → bucket 1; 4,5 → 2; 6,7 → 3.
+        AreEqual(1, byId[1]);
+        AreEqual(1, byId[2]);
+        AreEqual(1, byId[3]);
+        AreEqual(2, byId[4]);
+        AreEqual(2, byId[5]);
+        AreEqual(3, byId[6]);
+        AreEqual(3, byId[7]);
+    }
+
+    [TestMethod]
+    public void NTile_BucketsExceedRows_OneRowPerBucketThenEmpty()
+    {
+        // 3 rows / 5 buckets → first 3 buckets get 1 row each, last 2 buckets are empty.
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, ntile(5) over(order by id) from t where id <= 3").ExecuteReader();
+        var byId = new Dictionary<int, int>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt32(1);
+        AreEqual(1, byId[1]);
+        AreEqual(2, byId[2]);
+        AreEqual(3, byId[3]);
+    }
+
+    [TestMethod]
+    public void NTile_NonPositiveBucketCount_Raises9819()
+    {
+        using var connection = SeededTies();
+        var ex = Throws<DbException>(() =>
+            _ = connection.CreateCommand("select ntile(0) over(order by id) from t").ExecuteScalar());
+        AreEqual("9819", ex.Data["HelpLink.EvtID"]);
+    }
+
+    // === LAG / LEAD ===
+
+    [TestMethod]
+    public void Lag_DefaultOffsetOne_PartitionBoundaryNull()
+    {
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, lag(v) over(order by id) from t").ExecuteReader();
+        var byId = new Dictionary<int, int?>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.IsDBNull(1) ? null : reader.GetInt32(1);
+        IsNull(byId[1]); // First row: no predecessor → NULL.
+        AreEqual(10, byId[2]);
+        AreEqual(20, byId[3]);
+        AreEqual(20, byId[4]);
+        AreEqual(30, byId[5]);
+    }
+
+    [TestMethod]
+    public void Lag_ExplicitOffset_LooksBackFurther()
+    {
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, lag(v, 2) over(order by id) from t").ExecuteReader();
+        var byId = new Dictionary<int, int?>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.IsDBNull(1) ? null : reader.GetInt32(1);
+        IsNull(byId[1]);
+        IsNull(byId[2]);
+        AreEqual(10, byId[3]);
+        AreEqual(20, byId[4]);
+    }
+
+    [TestMethod]
+    public void Lag_WithDefaultExpression_SubstitutesAtBoundary()
+    {
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, lag(v, 1, -99) over(order by id) from t").ExecuteReader();
+        var byId = new Dictionary<int, int>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt32(1);
+        AreEqual(-99, byId[1]);
+        AreEqual(10, byId[2]);
+    }
+
+    [TestMethod]
+    public void Lead_MirrorsLagInOppositeDirection()
+    {
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, lead(v) over(order by id) from t").ExecuteReader();
+        var byId = new Dictionary<int, int?>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.IsDBNull(1) ? null : reader.GetInt32(1);
+        AreEqual(20, byId[1]);
+        AreEqual(20, byId[2]);
+        AreEqual(30, byId[3]);
+        IsNull(byId[7]); // Last row: no successor → NULL.
+    }
+
+    [TestMethod]
+    public void Lag_PartitionedDoesNotCrossPartitionBoundary()
+    {
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, lag(v) over(partition by grp order by id) from t").ExecuteReader();
+        var byId = new Dictionary<int, int?>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.IsDBNull(1) ? null : reader.GetInt32(1);
+        IsNull(byId[1]); // grp 1's first row.
+        IsNull(byId[5]); // grp 2's first row — wouldn't be NULL if partition was ignored.
+    }
+
+    // === FIRST_VALUE ===
+
+    [TestMethod]
+    public void FirstValue_ReturnsPartitionFirstAfterOrderBy()
+    {
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, first_value(v) over(partition by grp order by v) from t").ExecuteReader();
+        var byId = new Dictionary<int, int>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt32(1);
+        // grp 1: smallest v=10 → broadcast across rows 1,2,3,4.
+        // grp 2: smallest v=5 → broadcast across rows 5,6,7.
+        AreEqual(10, byId[1]);
+        AreEqual(10, byId[4]);
+        AreEqual(5, byId[5]);
+        AreEqual(5, byId[7]);
+    }
+
+    [TestMethod]
+    public void FirstValue_RespectsOrderByDirection()
+    {
+        // DESC ORDER BY → "first" is the max in each partition.
+        using var connection = SeededTies();
+        using var reader = connection.CreateCommand(
+            "select id, first_value(v) over(partition by grp order by v desc) from t").ExecuteReader();
+        var byId = new Dictionary<int, int>();
+        while (reader.Read())
+            byId[reader.GetInt32(0)] = reader.GetInt32(1);
+        AreEqual(30, byId[1]); // grp 1's largest v.
+        AreEqual(50, byId[5]); // grp 2's largest v.
+    }
 }

SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs

@@ -294,6 +294,14 @@ internal static SimulatedSqlException DistinctNotAllowedInOver() =>
     internal static SimulatedSqlException FunctionNotValidForOver(string functionLowerName) =>
         new($"The function '{functionLowerName}' is not a valid windowing function, and cannot be used with the OVER clause.", 4113, 15, 4);
 
+    /// <summary>
+    /// Mimics SQL Server's Msg 9819 — <c>NTILE(N)</c> requires <c>N</c> to be
+    /// a positive number; raised at runtime when the bucket-count expression
+    /// evaluates to zero or negative.
+    /// </summary>
+    internal static SimulatedSqlException NTileBucketCountMustBePositive() =>
+        new("The function 'NTILE' must have a positive integer value.", 9819, 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/Parser/Expression.cs

@@ -425,6 +425,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "COT" => new TrigFunction(context, TrigKind.Cot),
                 "EXP" => new Exp(context),
                 "IIF" => new Iif(context),
+                "LAG" => WindowExpression.ParseLag(context),
                 "LEN" => new Length(context),
                 "LOG" => new Log(context),
                 "MAX" => AggregateExpression.Parse(context, AggregateKind.Max),
@@ -442,7 +443,9 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "ATAN" => new TrigFunction(context, TrigKind.Atan),
                 "ATN2" => new Atn2(context),
                 "CAST" => new Cast(context),
+                "LEAD" => WindowExpression.ParseLead(context),
                 "LEFT" => new Left(context),
+                "RANK" => WindowExpression.ParseRank(context),
                 "SIGN" => new Sign(context),
                 "SQRT" => new Sqrt(context),
                 "TRIM" => new Trim(context),
@@ -457,6 +460,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "LOWER" => new Lower(context),
                 "LTRIM" => new LeftTrim(context),
                 "NEWID" => new NewId(context),
+                "NTILE" => WindowExpression.ParseNTile(context),
                 "POWER" => new Power(context),
                 "RIGHT" => new Right(context),
                 "ROUND" => new Round(context),
@@ -509,6 +513,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             10 => uppercaseName switch
             {
                 "DATALENGTH" => new DataLength(context),
+                "DENSE_RANK" => WindowExpression.ParseDenseRank(context),
                 "ERROR_LINE" => new ErrorLineFunction(context),
                 "GETUTCDATE" => new CurrentTimeFunction(context, CurrentTimeKind.GetUtcDate),
                 "JSON_VALUE" => new JsonValue(context),
@@ -519,6 +524,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             11 => uppercaseName switch
             {
                 "ERROR_STATE" => new ErrorStateFunction(context),
+                "FIRST_VALUE" => WindowExpression.ParseFirstValue(context),
                 "JSON_MODIFY" => new JsonModify(context),
                 "SYSDATETIME" => new CurrentTimeFunction(context, CurrentTimeKind.SysDateTime),
                 "TRY_CONVERT" => new ConvertExpression(context, tryMode: true),