fix(historian): #680 lane B — per-sample Count/Start/End/Delta per Part 13 + forward end-of-data Partial

Count: Good samples only, value-based status (all Bad => generic Bad), 0/Good on an empty interval inside the tag's data range [first, last] (both directions). Start/End: the raw first/last sample of any quality (own value, status, timestamp). Delta: Uncertain only when the interval's first or last sample is not usable. Forward end-of-data Partial (SDK m_endOfData, earlier edge inclusive) for every per-sample aggregate but Average (PercentGood/Bad left to lane A). Backends push down first/last-any-quality columns and fetch the tag's data range (earliest <= window end, latest >= window start) only when NeedsDataRange. SDK parity masks for Start/End/Delta/Count removed; new parity datasets.
2026-10-11 15:52:49 -04:00
parent f6a2628656
commit dbfe2fc4de
13 changed files with 644 additions and 136 deletions
@@ -21,6 +21,7 @@ public abstract class ProcessedConformance : ConformanceBase
    private const uint UncertainCalc = 0x40A40401u;   // UncertainDataSubNormal | 0x401
    private const uint NoDataCalc = 0x809B0401u;      // BadNoData | 0x401
    private const uint InvalidInputsCalc = 0x80D60401u; // BadAggregateInvalidInputs | 0x401
+    private const uint Partial = 0x4u;                  // the Partial aggregate bit (#677 start-of-data, #680 end-of-data)

    private async Task<HistoryReadResult> ReadA(HistoryAggregateType agg) =>
        await B.CreateDataSource().ReadProcessedAsync("A", At(0), At(80), Twenty, agg, Ct);
@@ -40,8 +41,6 @@ public abstract class ProcessedConformance : ConformanceBase
    [InlineData(HistoryAggregateType.Average, 15d, 40d, 50d)]
    [InlineData(HistoryAggregateType.Minimum, 10d, 40d, 50d)]
    [InlineData(HistoryAggregateType.Maximum, 20d, 40d, 50d)]
-    [InlineData(HistoryAggregateType.Start, 10d, 40d, 50d)]
-    [InlineData(HistoryAggregateType.End, 20d, 40d, 50d)]
    [InlineData(HistoryAggregateType.Delta, 10d, 0d, 0d)]
    [InlineData(HistoryAggregateType.Range, 10d, 0d, 0d)]
    public async Task Numeric_aggregates_over_the_fixture(HistoryAggregateType agg, double b0, double b1, double b2)
@@ -51,18 +50,65 @@ public abstract class ProcessedConformance : ConformanceBase

        s.Count.ShouldBe(4);
        s.Select(x => x.Value).ShouldBe([b0, b1, b2, null]);
-        // B1 holds a Bad sample alongside a usable one ⇒ Uncertain; the empty B3 ⇒ BadNoData.
-        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc, NoDataCalc]);
+        // B1 holds a Bad sample alongside a usable one ⇒ Uncertain (Delta: its first sample is the Bad one); the empty B3,
+        // after the last sample, ⇒ BadNoData. #680: B2 holds the last sample (+40) ⇒ end-of-data Partial on a forward
+        // read, for every aggregate but Average.
+        var b2Status = agg == HistoryAggregateType.Average ? GoodCalc : GoodCalc | Partial;
+        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, b2Status, NoDataCalc]);
        s.Select(x => x.SourceTimestampUtc).ShouldBe([B.Round(At(0)), B.Round(At(20)), B.Round(At(40)), B.Round(At(60))]); // bucket starts
    }

    [Fact]
-    public async Task Count_counts_usable_samples_as_int()
+    public async Task Start_and_End_return_the_raw_first_and_last_sample_of_any_quality()
    {
+        // #680 (Part 13 Tables 73/74; SDK ComputeStartEnd): the interval's raw first / last sample — its own value (null
+        // when Bad), its own status (Raw: no Calculated bit) and its own timestamp. B1's Start is the Bad sample at +20.
+        await ConformanceData.SeedAAsync(B);
+        var start = (await ReadA(HistoryAggregateType.Start)).Samples;
+        start.Select(x => x.Value).ShouldBe([10d, null, 50d, null]);
+        start.Select(x => x.StatusCode).ShouldBe([Good, Bad, Good | 0x400u | Partial, NoDataCalc]);
+        start.Select(x => x.SourceTimestampUtc).ShouldBe([B.Round(At(0)), B.Round(At(20)), B.Round(At(40)), B.Round(At(60))]);
+        var end = (await ReadA(HistoryAggregateType.End)).Samples;
+        end.Select(x => x.Value).ShouldBe([20d, 40d, 50d, null]);
+        end.Select(x => x.StatusCode).ShouldBe([Good, Good, Good | 0x400u | Partial, NoDataCalc]);
+        end.Select(x => x.SourceTimestampUtc).ShouldBe([B.Round(At(10)), B.Round(At(30)), B.Round(At(40)), B.Round(At(60))]);
+    }
+
+    [Fact]
+    public async Task Count_counts_good_samples_as_int()
+    {
+        // #680 (Part 13 §5.4.3.21): Good samples only, value-based status; end-of-data Partial on B2.
        await ConformanceData.SeedAAsync(B);
        var s = (await ReadA(HistoryAggregateType.Count)).Samples;
        s.Select(x => x.Value).ShouldBe([(object?)2, 1, 1, null]);
-        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc, NoDataCalc]);
+        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc | Partial, NoDataCalc]);
+    }
+
+    [Fact]
+    public async Task Count_is_zero_on_an_empty_interval_inside_the_data_range_in_both_directions()
+    {
+        // #680: +1 G, +2 U, +25 Bad, +45 G, +70 G. Forward [0,60) at 10 s: [10,20), [30,40) and [50,60) are empty but
+        // inside [first, last] ⇒ 0, Good; [20,30) holds only a Bad sample ⇒ generic Bad. Reverse (60 → 0) likewise, and a
+        // window wholly after the data ⇒ BadNoData — through the real SQL (the data range is two pushed-down seeks).
+        await B.SeedAsync("CZ",
+            (At(1), HistorianValue.FromDouble(10), Good),
+            (At(2), HistorianValue.FromDouble(10), Uncertain),
+            (At(25), HistorianValue.FromDouble(10), Bad),
+            (At(45), HistorianValue.FromDouble(10), Good),
+            (At(70), HistorianValue.FromDouble(1), Good));
+        var src = B.CreateDataSource();
+        var ten = TimeSpan.FromSeconds(10);
+        var fwd = (await src.ReadProcessedAsync("CZ", At(0), At(60), ten, HistoryAggregateType.Count, Ct)).Samples;
+        fwd.Select(x => x.Value).ShouldBe([(object?)1, 0, null, 0, 1, 0]);
+        fwd.Select(x => x.StatusCode).ShouldBe(
+            [UncertainCalc | Partial, GoodCalc, BadCalc, GoodCalc, GoodCalc, GoodCalc]);
+        var rev = (await src.ReadProcessedAsync("CZ", At(60), At(0), ten, HistoryAggregateType.Count, Ct)).Samples;
+        rev.Select(x => x.Value).ShouldBe([(object?)0, 1, 0, null, 0, 1]);
+        rev.Select(x => x.StatusCode).ShouldBe([GoodCalc, GoodCalc, GoodCalc, BadCalc, GoodCalc, UncertainCalc]);
+        (await src.ReadProcessedAsync("CZ", At(80), At(100), ten, HistoryAggregateType.Count, Ct)).Samples
+            .ShouldAllBe(x => x.StatusCode == NoDataCalc);
+        (await src.ReadProcessedAsync("CZ", At(-20), At(0), ten, HistoryAggregateType.Count, Ct)).Samples
+            .ShouldAllBe(x => x.StatusCode == NoDataCalc);
    }

    [Theory]
@@ -88,7 +134,8 @@ public abstract class ProcessedConformance : ConformanceBase
        var min = (await ReadA(HistoryAggregateType.MinimumActualTime)).Samples;
        min.Select(x => x.Value).ShouldBe([10d, 40d, 50d, null]);
        min.Select(x => x.SourceTimestampUtc).ShouldBe([B.Round(At(0)), B.Round(At(30)), B.Round(At(40)), B.Round(At(60))]);
-        min.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc, NoDataCalc]);
+        // #680: B2 holds the last sample (+40) ⇒ end-of-data Partial.
+        min.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc | Partial, NoDataCalc]);
        var max = (await ReadA(HistoryAggregateType.MaximumActualTime)).Samples;
        max.Select(x => x.Value).ShouldBe([20d, 40d, 50d, null]);
        max.Select(x => x.SourceTimestampUtc).ShouldBe([B.Round(At(10)), B.Round(At(30)), B.Round(At(40)), B.Round(At(60))]);
@@ -272,8 +319,9 @@ public abstract class ProcessedConformance : ConformanceBase
            (At(5), HistorianValue.FromDouble(10), Good),
            (At(15), HistorianValue.FromDouble(30), Good),
            (At(25), HistorianValue.FromDouble(20), Good));
+        // ... but LS2's data ENDS (+25) inside [20,40) ⇒ Partial there (#680, the SDK's m_endOfData rule).
        (await src.ReadProcessedAsync("LS2", At(0), At(40), Twenty, HistoryAggregateType.Count, Ct)).Samples
-            .ShouldAllBe(x => (x.StatusCode & 0x4u) == 0);
+            .Select(x => x.StatusCode & Partial).ShouldBe([0u, Partial]);
    }

    [Fact]
@@ -298,9 +346,7 @@ public abstract class ProcessedConformance : ConformanceBase
            ours.ShouldAllBe(x => (x.StatusCode & 0x4u) == 0, agg.ToString());
            var tw = AggregateFamilies.FamilyOf(agg) == AggregateFamily.TimeWeighted;
            SdkAggregateOracle.ShouldMatch(ours, SdkAggregateOracle.Run(agg, B.Round(At(40)), B.Round(At(0)), ten, sdkRows),
-                $"{agg} reverse late start", compareCalculatedInterpolatedBits: tw,
-                // pre-existing, #680: the SDK's Delta is Good with a Bad sample present; ours Uncertain (none here).
-                compareCodeBits: agg != HistoryAggregateType.Delta);
+                $"{agg} reverse late start", compareCalculatedInterpolatedBits: tw);
        }
    }

@@ -338,7 +384,6 @@ public abstract class ProcessedConformance : ConformanceBase
                 })
        {
            var ours = (await src.ReadProcessedAsync("P", At(from), At(to), interval, agg, Ct)).Samples.ToList();
-            var startOrEnd = agg is HistoryAggregateType.Start or HistoryAggregateType.End;
            var tw = AggregateFamilies.FamilyOf(agg) == AggregateFamily.TimeWeighted;
            if (tw && agg != HistoryAggregateType.Interpolative)
            {
@@ -372,9 +417,7 @@ public abstract class ProcessedConformance : ConformanceBase
            SdkAggregateOracle.ShouldMatch(ours, sdk,
                $"{agg} {from}→{to}/{intervalS}s",
                compareCalculatedInterpolatedBits: tw && !reverseInterpolative,
-                // pre-existing, #680: Start/End raw-sample timestamp + status; Delta status (see SdkAggregateParityTests).
-                compareCodeBits: agg != HistoryAggregateType.Delta && !reverseInterpolative && !startOrEnd,
-                compareTimestamps: !startOrEnd);
+                compareCodeBits: !reverseInterpolative);
        }
    }

@@ -417,7 +460,15 @@ public abstract class ProcessedConformance : ConformanceBase
            (await src.ReadProcessedAsync("Z", At(0), At(20), Twenty, a, Ct)).Samples.Single();

        (await One(HistoryAggregateType.Average)).StatusCode.ShouldBe(NoDataCalc);
-        (await One(HistoryAggregateType.Count)).StatusCode.ShouldBe(NoDataCalc);
+        // #680 (SDK value-based status): an interval holding only Bad samples counts as the generic Bad, value null.
+        var count = await One(HistoryAggregateType.Count);
+        count.StatusCode.ShouldBe(BadCalc);
+        count.Value.ShouldBeNull();
+        // Start is the raw first sample: the outage marker itself, with its own status and time.
+        var start = await One(HistoryAggregateType.Start);
+        start.StatusCode.ShouldBe(BadNoCommunication);
+        start.SourceTimestampUtc.ShouldBe(B.Round(At(1)));
+        start.Value.ShouldBeNull();
        var pb = await One(HistoryAggregateType.PercentBad);
        pb.Value.ShouldBe(100d);
        // The tag's data starts (+1) inside the interval ⇒ Partial on the non-Bad percentage (#677).
@@ -82,8 +82,15 @@ public sealed class ReadTests(QuestDbFixture fx) : IAsyncLifetime
        foreach (var agg in new[] { HistoryAggregateType.Average, HistoryAggregateType.Start, HistoryAggregateType.MaximumActualTime })
        {
            var s = (await src.ReadProcessedAsync("A", start, end, TimeSpan.Zero, agg, Ct)).Samples.Single();
-            // The data starts (+0) strictly inside the one interval ⇒ Partial on every aggregate but Average (#677).
-            s.StatusCode.ShouldBe(agg == HistoryAggregateType.Average ? UncertainCalc : UncertainCalc | 0x4u, agg.ToString());
+            // The data starts (+0) strictly inside the one interval ⇒ Partial on every aggregate but Average (#677). Start
+            // is the raw first sample (#680): its own Good status, no Calculated bit, plus InfoType + Partial.
+            var expected = agg switch
+            {
+                HistoryAggregateType.Average => UncertainCalc,
+                HistoryAggregateType.Start => 0x00000404u,
+                _ => UncertainCalc | 0x4u,
+            };
+            s.StatusCode.ShouldBe(expected, agg.ToString());
        }
        (await src.ReadProcessedAsync("A", start, end, TimeSpan.Zero, HistoryAggregateType.Average, Ct)).Samples.Single().Value.ShouldBe(30d);
        (await src.ReadProcessedAsync("A", start, end, TimeSpan.Zero, HistoryAggregateType.Start, Ct)).Samples.Single().Value.ShouldBe(10d);
@@ -21,31 +21,36 @@ public sealed class AggregateEvaluatorTests
            Bucket = 0, Total = 2, Usable = 2, Good = 2, Bad = 0, NonNumeric = 0, Avg = 15, Min = 10, Max = 20, Sum = 30,
            First = HistorianValue.FromDouble(10), Last = HistorianValue.FromDouble(20),
            Extreme = maximum ? 20 : 10, ExtremeTime = maximum ? At(10) : At(0),
+            FirstAny = A[0], LastAny = A[1],
        },
        [1] = new BucketRow
        {
            Bucket = 1, Total = 2, Usable = 1, Good = 1, Bad = 1, NonNumeric = 0, Avg = 40, Min = 40, Max = 40, Sum = 40,
            First = HistorianValue.FromDouble(40), Last = HistorianValue.FromDouble(40), Extreme = 40, ExtremeTime = At(30),
+            FirstAny = A[2], LastAny = A[3],
        },
        [2] = new BucketRow
        {
            Bucket = 2, Total = 1, Usable = 1, Good = 1, Bad = 0, NonNumeric = 0, Avg = 50, Min = 50, Max = 50, Sum = 50,
            First = HistorianValue.FromDouble(50), Last = HistorianValue.FromDouble(50), Extreme = 50, ExtremeTime = At(40),
+            FirstAny = A[4], LastAny = A[4],
        },
    };

+    private const uint Partial = 0x4u;
+    private const uint BadCalc = 0x80000401u; // generic Bad | Calculated
+
+    /// <summary>Tag A's data runs +0 … +40, so the forward read [0,80) holds the end of the data in B2 [40,60).</summary>
    private static IReadOnlyList<DataValueSnapshot> ReadA(HistoryAggregateType agg, bool maximum = false)
    {
        var plan = BucketPlan.Create(At(0), At(80), TimeSpan.FromSeconds(20));
-        return AggregateEvaluator.EvaluateAll(agg, plan, RowsA(maximum).Values, At(0), Now);
+        return AggregateEvaluator.EvaluateAll(agg, plan, RowsA(maximum).Values, At(0), At(40), Now);
    }

    [Theory]
    [InlineData(HistoryAggregateType.Average, 15d, 40d, 50d)]
    [InlineData(HistoryAggregateType.Minimum, 10d, 40d, 50d)]
    [InlineData(HistoryAggregateType.Maximum, 20d, 40d, 50d)]
-    [InlineData(HistoryAggregateType.Start, 10d, 40d, 50d)]
-    [InlineData(HistoryAggregateType.End, 20d, 40d, 50d)]
    [InlineData(HistoryAggregateType.Delta, 10d, 0d, 0d)]
    [InlineData(HistoryAggregateType.Range, 10d, 0d, 0d)]
    public void Numeric_aggregates_over_hand_built_bucket_rows(HistoryAggregateType agg, double b0, double b1, double b2)
@@ -53,16 +58,143 @@ public sealed class AggregateEvaluatorTests
        var s = ReadA(agg);
        s.Count.ShouldBe(4);
        s.Select(x => x.Value).ShouldBe([b0, b1, b2, null]);
-        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc, NoDataCalc]);
+        // #680: B2 holds the last sample (+40) ⇒ end-of-data Partial on a forward read, for every aggregate but Average.
+        // B1 opens on a Bad sample ⇒ Uncertain (for Delta: the interval's first sample was skipped).
+        var b2Status = agg == HistoryAggregateType.Average ? GoodCalc : GoodCalc | Partial;
+        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, b2Status, NoDataCalc]);
        s.Select(x => x.SourceTimestampUtc).ShouldBe([At(0), At(20), At(40), At(60)]);
    }

    [Fact]
-    public void Count_counts_usable_samples_as_int()
+    public void Start_and_End_return_the_raw_first_and_last_sample_of_any_quality()
    {
+        // #680 (Part 13 Tables 73/74; SDK ComputeStartEnd): the raw sample — its own value (null when Bad), its own status
+        // (Raw, no Calculated bit) and its own timestamp. B1's Start is the Bad sample at +20.
+        var start = ReadA(HistoryAggregateType.Start);
+        start.Select(x => x.Value).ShouldBe([10d, null, 50d, null]);
+        start.Select(x => x.StatusCode).ShouldBe([Good, Bad, Good | 0x400u | Partial, NoDataCalc]);
+        start.Select(x => x.SourceTimestampUtc).ShouldBe([At(0), At(20), At(40), At(60)]);
+        var end = ReadA(HistoryAggregateType.End);
+        end.Select(x => x.Value).ShouldBe([20d, 40d, 50d, null]);
+        end.Select(x => x.StatusCode).ShouldBe([Good, Good, Good | 0x400u | Partial, NoDataCalc]);
+        end.Select(x => x.SourceTimestampUtc).ShouldBe([At(10), At(30), At(40), At(60)]);
+    }
+
+    [Fact]
+    public void Start_and_End_follow_the_sample_order_in_a_reverse_read()
+    {
+        // Reverse (80 → 0): (20,40] = {+30, +40}, (0,20] = {+10, +20 Bad}. Start is still the EARLIEST sample of each
+        // interval and End the latest (the SDK's GetValues list is ascending in both directions).
+        var plan = BucketPlan.Create(At(80), At(0), TimeSpan.FromSeconds(20));
+        var rows = new[]
+        {
+            new BucketRow { Bucket = 1, Total = 2, Usable = 2, Good = 2, FirstAny = A[3], LastAny = A[4] },
+            new BucketRow { Bucket = 0, Total = 2, Usable = 1, Good = 1, Bad = 1, FirstAny = A[1], LastAny = A[2] },
+        };
+        var start = AggregateEvaluator.EvaluateAll(HistoryAggregateType.Start, plan, rows, At(0), At(40), Now);
+        start.Select(x => x.SourceTimestampUtc).ShouldBe([At(80), At(60), At(30), At(10)]);
+        start.Select(x => x.Value).ShouldBe([null, null, 40d, 20d]);
+        var end = AggregateEvaluator.EvaluateAll(HistoryAggregateType.End, plan, rows, At(0), At(40), Now);
+        end.Select(x => x.SourceTimestampUtc).ShouldBe([At(80), At(60), At(40), At(20)]);
+        end.Select(x => x.Value).ShouldBe([null, null, 50d, null]);
+        end.Select(x => x.StatusCode).ShouldBe([NoDataCalc, NoDataCalc, Good, Bad]);
+    }
+
+    [Fact]
+    public void Delta_is_good_when_a_bad_sample_sits_mid_interval_and_uncertain_when_one_bounds_it()
+    {
+        // SDK ComputeDelta: Uncertain only when the first or last sample of the interval is skipped (not usable).
+        var mid = new BucketRow
+        {
+            Total = 3, Usable = 2, Good = 2, Bad = 1, First = HistorianValue.FromDouble(1), Last = HistorianValue.FromDouble(4),
+            FirstAny = S(0, HistorianValue.FromDouble(1), Good), LastAny = S(9, HistorianValue.FromDouble(4), Good),
+        };
+        var d = AggregateEvaluator.Evaluate(HistoryAggregateType.Delta, mid, At(0), Now);
+        d.Value.ShouldBe(3d);
+        d.StatusCode.ShouldBe(GoodCalc);
+        mid.LastAny = S(9, HistorianValue.Empty, BadNoCommunication);
+        AggregateEvaluator.Evaluate(HistoryAggregateType.Delta, mid, At(0), Now).StatusCode.ShouldBe(UncertainCalc);
+        // An Uncertain bound is used (TreatUncertainAsBad = false), so it does not degrade Delta.
+        mid.LastAny = S(9, HistorianValue.FromDouble(4), Uncertain);
+        AggregateEvaluator.Evaluate(HistoryAggregateType.Delta, mid, At(0), Now).StatusCode.ShouldBe(GoodCalc);
+    }
+
+    [Fact]
+    public void Count_counts_good_samples_as_int()
+    {
+        // #680 (Part 13 §5.4.3.21; SDK ComputeCount): Good samples only; value-based status; end-of-data Partial on B2.
        var s = ReadA(HistoryAggregateType.Count);
        s.Select(x => x.Value).ShouldBe([(object?)2, 1, 1, null]);
-        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc, NoDataCalc]);
+        s.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc | Partial, NoDataCalc]);
+    }
+
+    [Fact]
+    public void Count_excludes_uncertain_samples_and_an_all_bad_interval_is_generic_bad()
+    {
+        var unc = new BucketRow { Total = 3, Usable = 3, Good = 1, Bad = 0 };
+        var c = AggregateEvaluator.Evaluate(HistoryAggregateType.Count, unc, At(0), Now);
+        c.Value.ShouldBe(1);
+        c.StatusCode.ShouldBe(UncertainCalc);
+        var bad = AggregateEvaluator.Evaluate(HistoryAggregateType.Count, new BucketRow { Total = 2, Bad = 2 }, At(0), Now);
+        bad.Value.ShouldBeNull();
+        bad.StatusCode.ShouldBe(BadCalc);
+    }
+
+    [Fact]
+    public void An_empty_interval_inside_the_data_range_counts_zero_and_outside_it_is_no_data()
+    {
+        // #680: forward [0,60) at 10 s over data +1 … +45: [10,20) and [30,40) hold no sample but lie inside
+        // [earliest, latest] ⇒ 0, Good; [50,60) is after the last sample ⇒ BadNoData.
+        var plan = BucketPlan.Create(At(0), At(60), TimeSpan.FromSeconds(10));
+        var rows = new[]
+        {
+            new BucketRow { Bucket = 0, Total = 1, Usable = 1, Good = 1 },
+            new BucketRow { Bucket = 2, Total = 1, Usable = 1, Good = 1 },
+            new BucketRow { Bucket = 4, Total = 1, Usable = 1, Good = 1 },
+        };
+        var s = AggregateEvaluator.EvaluateAll(HistoryAggregateType.Count, plan, rows, At(1), At(45), Now);
+        s.Select(x => x.Value).ShouldBe([(object?)1, 0, 1, 0, 1, null]);
+        s.Select(x => x.StatusCode).ShouldBe(
+            [GoodCalc | Partial, GoodCalc, GoodCalc, GoodCalc, GoodCalc | Partial, NoDataCalc]);
+        s.Select(x => x.SourceTimestampUtc).ShouldBe([At(0), At(10), At(20), At(30), At(40), At(50)]);
+
+        // Reverse (60 → 0): (40,50] is inside the range (its earlier edge +40 < +45); (50,60] is after it. A reverse read
+        // carries no Partial bits.
+        var rev = BucketPlan.Create(At(60), At(0), TimeSpan.FromSeconds(10));
+        var r = AggregateEvaluator.EvaluateAll(HistoryAggregateType.Count, rev, rows, At(1), At(45), Now);
+        r.Select(x => x.Value).ShouldBe([null, (object?)1, 0, 1, 0, 1]);
+        r.Select(x => x.StatusCode).ShouldBe([NoDataCalc, GoodCalc, GoodCalc, GoodCalc, GoodCalc, GoodCalc]);
+
+        // Other per-sample aggregates keep BadNoData on an empty interval.
+        AggregateEvaluator.EvaluateAll(HistoryAggregateType.Minimum, plan, rows, At(1), At(45), Now)[1].StatusCode
+            .ShouldBe(NoDataCalc);
+        // No data range known (an unknown tag / no sample near the window) ⇒ every empty interval is BadNoData.
+        AggregateEvaluator.EvaluateAll(HistoryAggregateType.Count, plan, [], null, null, Now)
+            .ShouldAllBe(x => x.StatusCode == NoDataCalc);
+    }
+
+    [Fact]
+    public void End_of_data_Partial_is_forward_only_and_inclusive_of_the_interval_start()
+    {
+        var row = new BucketRow { Bucket = 2, Total = 1, Usable = 1, Good = 1, Min = 3, Avg = 3 };
+        var fwd = BucketPlan.Create(At(0), At(40), TimeSpan.FromSeconds(10));
+        // Latest sample exactly on the interval's earlier edge (+20) ⇒ Partial (SDK m_endOfData >= startTime).
+        AggregateEvaluator.EvaluateAll(HistoryAggregateType.Minimum, fwd, [row], At(-5), At(20), Now)[2].StatusCode
+            .ShouldBe(GoodCalc | Partial);
+        // Data past the window end ⇒ no end-of-data Partial.
+        AggregateEvaluator.EvaluateAll(HistoryAggregateType.Minimum, fwd, [row], At(-5), At(100), Now)[2].StatusCode
+            .ShouldBe(GoodCalc);
+        // Average never sets it.
+        AggregateEvaluator.EvaluateAll(HistoryAggregateType.Average, fwd, [row], At(-5), At(25), Now)[2].StatusCode
+            .ShouldBe(GoodCalc);
+        // A Bad result never carries Partial (ours; the SDK sets it on a Bad result too).
+        var bad = new BucketRow { Bucket = 2, Total = 1, Bad = 1 };
+        AggregateEvaluator.EvaluateAll(HistoryAggregateType.Minimum, fwd, [bad], At(-5), At(25), Now)[2].StatusCode
+            .ShouldBe(NoDataCalc);
+        // Reverse: not applied.
+        var rev = BucketPlan.Create(At(40), At(0), TimeSpan.FromSeconds(10));
+        AggregateEvaluator.EvaluateAll(HistoryAggregateType.Minimum, rev, [row], At(-5), At(25), Now)
+            .ShouldAllBe(x => (x.StatusCode & Partial) == 0);
    }

    [Theory]
@@ -81,7 +213,7 @@ public sealed class AggregateEvaluatorTests
        var min = ReadA(HistoryAggregateType.MinimumActualTime);
        min.Select(x => x.Value).ShouldBe([10d, 40d, 50d, null]);
        min.Select(x => x.SourceTimestampUtc).ShouldBe([At(0), At(30), At(40), At(60)]);
-        min.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc, NoDataCalc]);
+        min.Select(x => x.StatusCode).ShouldBe([GoodCalc, UncertainCalc, GoodCalc | Partial, NoDataCalc]);
        var max = ReadA(HistoryAggregateType.MaximumActualTime, maximum: true);
        max.Select(x => x.Value).ShouldBe([20d, 40d, 50d, null]);
        max.Select(x => x.SourceTimestampUtc).ShouldBe([At(10), At(30), At(40), At(60)]);
@@ -107,6 +239,8 @@ public sealed class AggregateEvaluatorTests
        avg.Value.ShouldBeNull();
        avg.StatusCode.ShouldBe(NoDataCalc);
        AggregateEvaluator.Evaluate(HistoryAggregateType.PercentBad, row, At(0), Now).Value.ShouldBe(100d);
+        // #680: Count of an all-Bad interval is the generic Bad (the SDK's value-based status), not BadNoData.
+        AggregateEvaluator.Evaluate(HistoryAggregateType.Count, row, At(0), Now).StatusCode.ShouldBe(BadCalc);
    }

    [Fact]
@@ -133,15 +133,44 @@ public sealed class BucketPlanTests
    }

    [Fact]
-    public void The_earliest_sample_is_needed_only_for_forward_reads_of_aggregates_other_than_Average()
+    public void Data_ends_inside_from_the_interval_start_inclusive_to_its_end_exclusive()
    {
-        // Review F2: backends skip the earliest-sample query when its answer cannot change a result.
+        var p = BucketPlan.Create(At(0), At(40), TimeSpan.FromSeconds(20));
+        p.DataEndsInside(0, At(5)).ShouldBeTrue();
+        p.DataEndsInside(1, At(20)).ShouldBeTrue(); // on the earlier edge: the SDK's m_endOfData >= startTime
+        p.DataEndsInside(0, At(20)).ShouldBeFalse();
+        p.DataEndsInside(1, At(40)).ShouldBeFalse();
+        p.DataEndsInside(0, null).ShouldBeFalse();
+    }
+
+    [Fact]
+    public void The_data_range_includes_both_of_its_edges()
+    {
+        var p = BucketPlan.Create(At(0), At(60), TimeSpan.FromSeconds(20));
+        p.WithinDataRange(0, At(10), At(30)).ShouldBeTrue();
+        p.WithinDataRange(1, At(10), At(30)).ShouldBeTrue();
+        p.WithinDataRange(2, At(10), At(30)).ShouldBeFalse();  // [40,60) is after the last sample
+        p.WithinDataRange(2, At(10), At(40)).ShouldBeTrue();   // last sample on the earlier edge
+        p.WithinDataRange(0, At(20), At(30)).ShouldBeTrue();   // first sample on the later edge
+        p.WithinDataRange(0, At(21), At(30)).ShouldBeFalse();
+        p.WithinDataRange(0, null, At(30)).ShouldBeFalse();
+        p.WithinDataRange(0, At(10), null).ShouldBeFalse();
+    }
+
+    [Fact]
+    public void The_data_range_is_needed_for_forward_reads_of_aggregates_other_than_Average_and_for_Count()
+    {
+        // Review F2 (#677) / #680: backends skip the earliest/latest-sample queries when their answer cannot change a
+        // result — the start/end-of-data Partial rules are forward-only and not Average's; Count's in-range empty interval
+        // (0, not BadNoData) applies in both directions.
        var fwd = BucketPlan.Create(At(0), At(40), TimeSpan.FromSeconds(10));
        var rev = BucketPlan.Create(At(40), At(0), TimeSpan.FromSeconds(10));
-        AggregateEvaluator.NeedsEarliestSample(HistoryAggregateType.Count, fwd).ShouldBeTrue();
-        AggregateEvaluator.NeedsEarliestSample(HistoryAggregateType.Average, fwd).ShouldBeFalse();
-        AggregateEvaluator.NeedsEarliestSample(HistoryAggregateType.Count, rev).ShouldBeFalse();
-        AggregateEvaluator.NeedsEarliestSample(HistoryAggregateType.Count, BucketPlan.Create(At(0), At(0), TimeSpan.Zero))
+        AggregateEvaluator.NeedsDataRange(HistoryAggregateType.Count, fwd).ShouldBeTrue();
+        AggregateEvaluator.NeedsDataRange(HistoryAggregateType.Minimum, fwd).ShouldBeTrue();
+        AggregateEvaluator.NeedsDataRange(HistoryAggregateType.Average, fwd).ShouldBeFalse();
+        AggregateEvaluator.NeedsDataRange(HistoryAggregateType.Count, rev).ShouldBeTrue();
+        AggregateEvaluator.NeedsDataRange(HistoryAggregateType.Minimum, rev).ShouldBeFalse();
+        AggregateEvaluator.NeedsDataRange(HistoryAggregateType.Count, BucketPlan.Create(At(0), At(0), TimeSpan.Zero))
            .ShouldBeFalse();
    }

@@ -16,9 +16,9 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Sql.Common.Tests;
 /// <remarks>
 ///     Deliberate, documented divergences the datasets avoid (they are not anchoring questions):
 ///     <list type="bullet">
-///       <item>an <b>empty</b> interval inside the data range: the SDK's Count answers 0/Good, ours <c>BadNoData</c>;</item>
-///       <item><b>Uncertain</b> samples in a per-sample aggregate: the SDK's Average/Count/Min/Max use Good samples only,
-///         ours every usable (Good + Uncertain) sample (TreatUncertainAsBad = false applied consistently);</item>
+///       <item><b>Uncertain</b> samples in a per-sample aggregate: the SDK's Average/Min/Max use Good samples only,
+///         ours every usable (Good + Uncertain) sample (TreatUncertainAsBad = false applied consistently). Count matches
+///         the SDK since #680 (Good samples only);</item>
 ///       <item>the per-sample <b>Calculated / MultipleValues</b> info bits (the SDK's MinMax sets Calculated only when the
 ///         extreme is not at the interval start, and flags ties) — those comparisons check code bits + Partial only;</item>
 ///       <item>a <b>truncated</b> interval: ours sets Partial on a non-Bad time-weighted result (Part 13 §5.3.3.2 Case 3
@@ -46,6 +46,8 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Sql.Common.Tests;
 ///         <c>UpdateSlice</c> files it as the early bound (below), so the interval takes the status of the segment beyond
 ///         it (Uncertain when that segment skips a Bad sample); ours keeps the interval's own segments — masked by
 ///         <see cref="MaskDocumented"/>;</item>
+///       <item>a <b>Bad</b> per-sample result never carries Partial (the SDK sets start/end-of-data Partial on Bad results
+///         too) — the datasets keep the data's start and end out of all-Bad intervals;</item>
 ///       <item><b>Interpolative, reverse, a sample exactly at the point:</b> the SDK's backward <c>UpdateSlice</c> files
 ///         a sample AT the point as the early bound (<c>&gt;= 0</c>), so it interpolates from it to the next Good sample —
 ///         same value, but the Interpolated bit, and Uncertain when a Bad sample sits between. Ours returns the raw
@@ -164,7 +166,7 @@ public sealed class SdkAggregateParityTests
        if (AggregateFamilies.FamilyOf(agg) == AggregateFamily.TimeWeighted)
            return TimeWeightedAggregator.Evaluate(agg, plan, data, Now);
        return AggregateEvaluator.EvaluateAll(agg, plan, InMemoryRows(plan, data, agg == HistoryAggregateType.MaximumActualTime),
-            data.Min(s => s.TimeUtc), Now);
+            data.Min(s => s.TimeUtc), data.Max(s => s.TimeUtc), Now);
    }

    private static IReadOnlyList<SdkAggregateOracle.Result> Sdk(HistoryAggregateType agg, double from, double to,
@@ -305,12 +307,7 @@ public sealed class SdkAggregateParityTests
            {
                SdkAggregateOracle.ShouldMatch(Ours(agg, from, to, intervalS, Dense), Sdk(agg, from, to, intervalS, Dense),
                    $"{agg} Dense {from}→{to}/{intervalS}s", compareCalculatedInterpolatedBits: false,
-                    // pre-existing, #680: the SDK's Start/End return the raw first/last sample (any quality) with its own
-                    // timestamp and stored status; ours return the first/last USABLE value stamped with the interval, under the
-                    // per-sample status rule. The SDK's Delta is Good even when a Bad sample sits in the interval; ours is
-                    // Uncertain. Values are compared wherever the SDK's answer is not Bad.
-                    compareTimestamps: !StartOrEnd(agg),
-                    compareCodeBits: !StartOrEnd(agg) && agg != HistoryAggregateType.Delta);
+                    compareValues: true);
            }
            catch (Exception ex)
            {
@@ -327,8 +324,6 @@ public sealed class SdkAggregateParityTests
        HistoryAggregateType.Delta, HistoryAggregateType.MinimumActualTime, HistoryAggregateType.MaximumActualTime,
    ];

-    private static bool StartOrEnd(HistoryAggregateType agg) =>
-        agg is HistoryAggregateType.Start or HistoryAggregateType.End;

    [Theory]
    [InlineData(HistoryAggregateType.TimeAverage)]
@@ -351,9 +346,7 @@ public sealed class SdkAggregateParityTests
        var ours = Ours(agg, 40, 0, 10, LateStart);
        SdkAggregateOracle.ShouldMatch(ours, Sdk(agg, 40, 0, 10, LateStart), $"{agg} reverse LateStart",
            compareCalculatedInterpolatedBits: tw,
-            // pre-existing, #680: Start's raw-sample timestamp/status (see Per_sample_aggregates_match_the_SDK).
-            compareTimestamps: !StartOrEnd(agg),
-            compareCodeBits: !StartOrEnd(agg) && agg != HistoryAggregateType.Delta);
+            compareCodeBits: true);
        ours.ShouldAllBe(x => (x.StatusCode & HistorianInfoBits.HistorianPartial) == 0);
    }

@@ -379,6 +372,121 @@ public sealed class SdkAggregateParityTests
        ours.Skip(1).ShouldAllBe(x => (x.StatusCode & HistorianInfoBits.HistorianPartial) == 0);
    }

+    /// <summary>
+    ///     #680: sparse data with Good, Uncertain and Bad samples, empty intervals inside the data range, and intervals before
+    ///     and after it: +1 G, +2 U, +25 Bad, +45 G, +70 G.
+    /// </summary>
+    private static readonly StoredSample[] Gappy =
+    [
+        S(1, HistorianValue.FromDouble(10), Good),
+        S(2, HistorianValue.FromDouble(11), Uncertain),
+        S(25, HistorianValue.FromDouble(12), Bad),
+        S(45, HistorianValue.FromDouble(13), Good),
+        S(70, HistorianValue.FromDouble(1), Good),
+    ];
+
+    /// <summary>#680: Bad samples leading, trailing and mid-interval, plus an Uncertain one (Start / End / Delta).</summary>
+    private static readonly StoredSample[] Bracketed =
+    [
+        S(-5, HistorianValue.FromDouble(1), Good),
+        S(1, HistorianValue.FromDouble(10), Bad),
+        S(3, HistorianValue.FromDouble(11), Good),
+        S(5, HistorianValue.FromDouble(12), Bad),
+        S(7, HistorianValue.FromDouble(13), Uncertain),
+        S(9, HistorianValue.FromDouble(15), Good),
+        S(12, HistorianValue.FromDouble(20), Good),
+        S(14, HistorianValue.Empty, BadNoCommunication),
+        S(16, HistorianValue.FromDouble(21), Good),
+        S(19, HistorianValue.Empty, BadNoCommunication),
+        S(40, HistorianValue.FromDouble(1), Good),
+    ];
+
+    public static TheoryData<double, double, double> GappyWindows => new()
+    {
+        { 0, 60, 10 }, { 60, 0, 10 },   // empty intervals inside the data range; +70 is past the window
+        { -10, 1, 5 }, { 1, -10, 5 },   // intervals before the first sample; one ending ON it (forward)
+        { 70, 85, 5 }, { 85, 70, 5 },   // intervals after the last sample; one starting ON it (reverse)
+        { 0, 1, 1 },                    // one interval ending exactly on the first sample: empty but in range
+    };
+
+    [Theory]
+    [MemberData(nameof(GappyWindows))]
+    public void Count_Start_End_and_Delta_match_the_SDK_across_the_data_range(double from, double to, double intervalS)
+    {
+        // #680: Count over Good samples only with the value-based status, 0 (not BadNoData) for an empty interval inside
+        // [first, last], BadNoData outside it; Start/End the raw first/last sample; Delta's status from its bounding samples.
+        var failures = new List<string>();
+        foreach (var agg in new[]
+                 {
+                     HistoryAggregateType.Count, HistoryAggregateType.Start, HistoryAggregateType.End, HistoryAggregateType.Delta,
+                 })
+        foreach (var (name, data) in new[] { ("Gappy", Gappy), ("Bracketed", Bracketed) })
+        {
+            try
+            {
+                SdkAggregateOracle.ShouldMatch(Ours(agg, from, to, intervalS, data), Sdk(agg, from, to, intervalS, data),
+                    $"{agg} {name} {from}→{to}/{intervalS}s", compareCalculatedInterpolatedBits: false);
+            }
+            catch (Exception ex)
+            {
+                failures.Add(ex.Message);
+            }
+        }
+        failures.ShouldBeEmpty(string.Join("\n", failures));
+    }
+
+    [Theory]
+    [InlineData(0, 20, 10)]
+    [InlineData(20, 0, 10)]
+    [InlineData(0, 20, 0)]
+    [InlineData(20, 0, 0)]
+    public void Start_End_and_Delta_over_bad_bounding_samples_match_the_SDK_exactly(double from, double to, double intervalS)
+    {
+        // #680: with the raw sample's own status (incl. a Bad one and its null value) Start/End must match the SDK to the
+        // bit; Delta's Calculated bit as well.
+        foreach (var agg in new[] { HistoryAggregateType.Start, HistoryAggregateType.End, HistoryAggregateType.Delta })
+            SdkAggregateOracle.ShouldMatch(Ours(agg, from, to, intervalS, Bracketed), Sdk(agg, from, to, intervalS, Bracketed),
+                $"{agg} Bracketed {from}→{to}/{intervalS}s");
+    }
+
+    /// <summary>#680: data ending inside the window (−5, +3, +25) and ending exactly on an interval edge (+20).</summary>
+    private static readonly StoredSample[] EarlyEnd =
+        [S(-5, HistorianValue.FromDouble(1), Good), S(3, HistorianValue.FromDouble(2), Good), S(25, HistorianValue.FromDouble(3), Good)];
+
+    private static readonly StoredSample[] EndOnEdge =
+        [S(-5, HistorianValue.FromDouble(1), Good), S(3, HistorianValue.FromDouble(2), Good), S(20, HistorianValue.FromDouble(3), Good)];
+
+    [Theory]
+    [InlineData(0, 40, 10)]
+    [InlineData(0, 40, 25)]
+    [InlineData(0, 40, 0)]
+    [InlineData(40, 0, 10)]
+    public void The_interval_the_data_ends_inside_matches_the_SDK_Partial_bit(double from, double to, double intervalS)
+    {
+        // #680 (Part 13 §5.3.3.2 Case 2; SDK m_endOfData): forward, the interval holding the last sample (its earlier edge
+        // included) is Partial for every per-sample aggregate but Average. Reverse 40 → 0 over EndOnEdge: the SDK's
+        // reverse rule (strictly inside, see the remarks) does not fire on an edge, and ours sets nothing.
+        var failures = new List<string>();
+        var datasets = from > to ? new[] { ("EndOnEdge", EndOnEdge) } : new[] { ("EarlyEnd", EarlyEnd), ("EndOnEdge", EndOnEdge) };
+        foreach (var agg in PerSample)
+        foreach (var (name, data) in datasets)
+        {
+            try
+            {
+                SdkAggregateOracle.ShouldMatch(Ours(agg, from, to, intervalS, data), Sdk(agg, from, to, intervalS, data),
+                    $"{agg} {name} {from}→{to}/{intervalS}s", compareCalculatedInterpolatedBits: false);
+            }
+            catch (Exception ex)
+            {
+                failures.Add(ex.Message);
+            }
+        }
+        failures.ShouldBeEmpty(string.Join("\n", failures));
+        // Not vacuous: the forward EarlyEnd read does flag [20,30) (and only it).
+        Ours(HistoryAggregateType.Minimum, 0, 40, 10, EarlyEnd).Select(x => x.StatusCode & HistorianInfoBits.HistorianPartial)
+            .ShouldBe([0u, 0u, HistorianInfoBits.HistorianPartial, 0u]);
+    }
+
    /// <summary>The per-bucket statistics the backends' SQL computes, built in memory with <see cref="BucketPlan.IndexOf"/>.</summary>
    internal static IEnumerable<BucketRow> InMemoryRows(BucketPlan plan, IEnumerable<StoredSample> samples, bool maximum = false)
    {
@@ -408,6 +516,8 @@ public sealed class SdkAggregateParityTests
                Last = usable.Count == 0 ? HistorianValue.Empty : usable[^1].Value,
                Extreme = extreme?.Value.Number,
                ExtremeTime = extreme?.TimeUtc,
+                FirstAny = all[0],
+                LastAny = all[^1],
            };
        }
    }