fix(historian): live-gate 8 F1 — per-sample counts and picks from one table version (#680 follow-up)

QuestDB Start/End/Delta reads of a tag being written intermittently failed BadHistoryOperationUnsupported (InvalidCastException: Column 'ts_3' is null): the StartEnd query referenced its CTE four times and QuestDB opens a table reader per reference, so a row committed between two of them was counted but not picked. MinimumActualTime/MaximumActualTime had the same race and returned a value-less Good. (a) SQL - QuestDB StartEnd: one scan, one GROUP BY — first()/last() for the any-quality picks, arg_min/arg_max keyed on the usable rows' time for the usable picks (no str_value: arg_min has no VARCHAR form; only Delta reads them). Byte-identical output to the old query on a 1M-row tag, ~15% faster. - SqlServer StartEnd: one windowed pass + conditional MAX (was five CTE references); identical output, 1.4-3x faster. - ActualTime kept on both backends: every single-scan form measured 1.2-2.4x slower; its inconsistency is absorbed by (b). (b) Defence in depth on both backends - ReadBucket takes DbDataReader and reads absent picks as null (ReadStoredOrNull) instead of throwing. - AggregateEvaluator: Delta with a missing first/last usable pick and ActualTime with a missing extreme are BadNoData (were BadAggregateInvalidInputs / a value-less Good); Start/End with no pick already were. - Unit tests (Sql.Common evaluator, QuestDb + SqlServer mappers over a DataTableReader) fail with the guards removed. LiveWriteReadRaceStressTests (QuestDB integration, opt-in via HISTORIAN_QUESTDB_STRESS_SECONDS, Category=SlowUnit): single-row writer vs 4 tight-loop readers. Old code: 6 faults in ~105k reads; new: 0 in 106k. Docs: Historian.md QuestDB processed-read note; F2 (Min/Max on the interval start: SDK raw, ours Calculated) and F3 (integer tags: SDK casts interpolated values to the integer type, ours Double) added to the SDK-parity deviations.
2026-10-11 18:28:29 -04:00
parent 11f792538e
commit 2ceed561ad
13 changed files with 549 additions and 54 deletions
@@ -83,33 +83,54 @@ internal static class QuestDbAggregateQueries
    ///     (<c>ts, kind, num_value, int_value, str_value, status</c>) and <c>22..27</c> the last (same order), present for
    ///     every returned (non-empty) bucket.
    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///         <b>One scan, one GROUP BY (live-gate 8 F1).</b> The counts and all four picked samples come from a single read
+    ///         of the sample table. The first/last sample of any quality are QuestDB's <c>first()</c>/<c>last()</c> (the
+    ///         first/last row of the group in designated-timestamp order — null values included, so every column comes from
+    ///         the same row); the first/last <i>usable</i> sample are <c>arg_min</c>/<c>arg_max</c> keyed on <c>uts</c>, the
+    ///         row's time when usable and NULL otherwise (a NULL key is skipped, a NULL value is returned as is, and
+    ///         <c>(ts, tag)</c> is unique — DEDUP — so there are no ties). <c>arg_min</c> has no VARCHAR form, so the usable
+    ///         picks carry no <c>str_value</c>: only Delta reads them, and only when the bucket has no usable non-numeric
+    ///         sample.
+    ///     </para>
+    ///     <para>
+    ///         The previous form referenced its CTE four times (counts + three self-joins); QuestDB opens a separate table
+    ///         reader per reference, so a row committed between two of them produced a bucket whose counts included a sample
+    ///         its first/last join could not find (a NULL first-of-any-quality time that threw) — ~1 in 90k reads of a tag
+    ///         being written. One reference means one reader at one table version. A windowed (<c>row_number()</c>)
+    ///         single-scan form was also correct but ~2× slower; this one is not slower than the old query.
+    ///     </para>
+    /// </remarks>
    /// <param name="sample">Prefixed sample table name.</param>
    /// <returns>The SQL text.</returns>
    /// <param name="reverse">True for a reverse read (window <c>($4, $5]</c>).</param>
-    public static string StartEnd(string sample, bool reverse = false) =>
-        "WITH s AS (" + Classified(sample, reverse) + "), " +
-        "st AS (SELECT b, " + CommonCounts() + " FROM s GROUP BY b), " +
-        "f AS (SELECT b, kind, num_value, int_value, str_value, ts, " +
-        "row_number() OVER (PARTITION BY b ORDER BY ts ASC) AS rf, " +
-        "row_number() OVER (PARTITION BY b ORDER BY ts DESC) AS rl FROM s WHERE u = 1), " +
-        "a AS (SELECT b, ts, kind, num_value, int_value, str_value, status, " +
-        "row_number() OVER (PARTITION BY b ORDER BY ts ASC) AS rf, " +
-        "row_number() OVER (PARTITION BY b ORDER BY ts DESC) AS rl FROM s) " +
-        "SELECT st.*, " +
-        "x.kind, x.num_value, x.int_value, x.str_value, x.ts, " +
-        "y.kind, y.num_value, y.int_value, y.str_value, y.ts, " +
-        "p.ts, p.kind, p.num_value, p.int_value, p.str_value, p.status, " +
-        "q.ts, q.kind, q.num_value, q.int_value, q.str_value, q.status " +
-        "FROM st LEFT JOIN (SELECT * FROM f WHERE rf = 1) x ON x.b = st.b " +
-        "LEFT JOIN (SELECT * FROM f WHERE rl = 1) y ON y.b = st.b " +
-        "LEFT JOIN (SELECT * FROM a WHERE rf = 1) p ON p.b = st.b " +
-        "LEFT JOIN (SELECT * FROM a WHERE rl = 1) q ON q.b = st.b ORDER BY st.b";
+    public static string StartEnd(string sample, bool reverse = false)
+    {
+        // The usable picks: kind, num_value, int_value, str_value (not available — see remarks), ts.
+        static string Usable(string f, string g) =>
+            $"cast({f}(kind, uts) AS SHORT), {f}(num_value, uts), {f}(int_value, uts), cast(NULL AS VARCHAR), {g}(uts)";
+        // The any-quality picks: ts, kind, num_value, int_value, str_value, status — all from the group's first / last row.
+        static string Any(string f) =>
+            $"{f}(ts), cast({f}(kind) AS SHORT), {f}(num_value), {f}(int_value), {f}(str_value), {f}(status)";
+        return "SELECT b, " + CommonCounts() + ", " +
+               Usable("arg_min", "min") + ", " + Usable("arg_max", "max") + ", " + Any("first") + ", " + Any("last") + " " +
+               "FROM (SELECT b, ts, kind, num_value, int_value, str_value, status, u, g, CASE WHEN u = 1 THEN ts END AS uts " +
+               "FROM (" + Classified(sample, reverse) + ")) GROUP BY b ORDER BY b";
+    }

    /// <summary>
    ///     MinimumActualTime / MaximumActualTime: the usable sample with the smallest (largest) <c>num_value</c>, ties
    ///     broken by the earliest <c>ts</c>. Family columns: <c>6 num_value, 7 ts</c> (NULL when the bucket has no usable
    ///     numeric sample).
    /// </summary>
+    /// <remarks>
+    ///     Deliberately still two references to the classified rows (counts + the ranked extreme), unlike
+    ///     <see cref="StartEnd"/>: the single-scan <c>row_number()</c> form measured ~2× slower, and QuestDB's
+    ///     <c>arg_max</c>/<c>arg_min</c> cannot express the earliest-time tie-break. Live-gate 8 F1's inconsistency (a row
+    ///     committed between the two readers — counted but not ranked) is absorbed by the reader and evaluator instead: a
+    ///     NULL extreme in a bucket with usable samples evaluates to <c>BadNoData</c>, never a value-less Good.
+    /// </remarks>
    /// <param name="sample">Prefixed sample table name.</param>
    /// <param name="maximum">True for MaximumActualTime.</param>
    /// <returns>The SQL text.</returns>
@@ -201,14 +201,14 @@ internal sealed class QuestDbConnection : IAsyncDisposable, IDisposable
    /// <param name="r">Reader positioned on a row.</param>
    /// <param name="i">Column ordinal.</param>
    /// <returns>The timestamp with <c>Kind=Utc</c>.</returns>
-    public static DateTime ReadUtc(NpgsqlDataReader r, int i) =>
+    public static DateTime ReadUtc(System.Data.Common.DbDataReader r, int i) =>
        DateTime.SpecifyKind(r.GetDateTime(i), DateTimeKind.Utc);

    /// <summary>Reads a <c>BYTE</c> column (QuestDB returns <c>smallint</c>); NULL (never stored) reads as 0 (Empty).</summary>
    /// <param name="r">Reader positioned on a row.</param>
    /// <param name="i">Column ordinal.</param>
    /// <returns>The byte value.</returns>
-    public static byte ReadKind(NpgsqlDataReader r, int i) => r.IsDBNull(i) ? (byte)0 : (byte)r.GetInt16(i);
+    public static byte ReadKind(System.Data.Common.DbDataReader r, int i) => r.IsDBNull(i) ? (byte)0 : (byte)r.GetInt16(i);

    // ---- error classification --------------------------------------------------------------------------------------

@@ -1,3 +1,4 @@
+using System.Data.Common;
 using System.Globalization;
 using System.Text;
 using Microsoft.Extensions.Logging;
@@ -574,12 +575,22 @@ public sealed class QuestDbHistorianDataSource : IHistorianDataSource
        return await reader.ReadAsync(ct).ConfigureAwait(false) && !reader.IsDBNull(0) ? QuestDbConnection.ReadUtc(reader, 0) : null;
    }

-    private static BucketRow ReadBucket(NpgsqlDataReader reader, AggregateFamily family)
+    /// <summary>
+    ///     Maps one per-sample aggregate row (<see cref="QuestDbAggregateQueries"/> column layout) to a
+    ///     <see cref="BucketRow"/>. Every picked sample — first/last usable, first/last of any quality, the extreme — is
+    ///     optional: a NULL time reads as "no such sample", never an exception (live-gate 8 F1: a row whose counts and
+    ///     picks disagreed used to throw out of <see cref="ReadStored"/> and fail the node's whole read; the evaluator
+    ///     answers such a bucket from what is present, or <c>BadNoData</c>).
+    /// </summary>
+    /// <param name="reader">Reader positioned on a bucket row.</param>
+    /// <param name="family">The query's aggregate family.</param>
+    /// <returns>The bucket statistics.</returns>
+    internal static BucketRow ReadBucket(DbDataReader reader, AggregateFamily family)
    {
-        static double? D(NpgsqlDataReader r, int i) => r.IsDBNull(i) ? null : r.GetDouble(i);
-        static int N(NpgsqlDataReader r, int i) => r.IsDBNull(i) ? 0 : Convert.ToInt32(r.GetValue(i), CultureInfo.InvariantCulture);
+        static double? D(DbDataReader r, int i) => r.IsDBNull(i) ? null : r.GetDouble(i);
+        static int N(DbDataReader r, int i) => r.IsDBNull(i) ? 0 : Convert.ToInt32(r.GetValue(i), CultureInfo.InvariantCulture);
        // A bucket without a usable sample has NULL times but kind 0 (BYTE has no NULL): absence is keyed on the time.
-        static HistorianValue V(NpgsqlDataReader r, int i) =>
+        static HistorianValue V(DbDataReader r, int i) =>
            r.IsDBNull(i + 4)
                ? HistorianValue.Empty
                : ToValue(QuestDbConnection.ReadKind(r, i), D(r, i + 1), r.IsDBNull(i + 2) ? null : r.GetInt64(i + 2),
@@ -606,8 +617,8 @@ public sealed class QuestDbHistorianDataSource : IHistorianDataSource
            case AggregateFamily.StartEnd:
                row.First = V(reader, f);
                row.Last = V(reader, f + 5);
-                row.FirstAny = ReadStored(reader, QuestDbAggregateQueries.FirstAnyColumn);
-                row.LastAny = ReadStored(reader, QuestDbAggregateQueries.FirstAnyColumn + 6);
+                row.FirstAny = ReadStoredOrNull(reader, QuestDbAggregateQueries.FirstAnyColumn);
+                row.LastAny = ReadStoredOrNull(reader, QuestDbAggregateQueries.FirstAnyColumn + 6);
                break;
            default:
                row.Extreme = D(reader, f);
@@ -623,7 +634,7 @@ public sealed class QuestDbHistorianDataSource : IHistorianDataSource
    ///     Reads <c>ts, kind, num_value, int_value, str_value, status</c> starting at <paramref name="o"/> and applies the
    ///     shared quality clamp (<see cref="StoredSample.FromStored"/>).
    /// </summary>
-    private static StoredSample ReadStored(NpgsqlDataReader r, int o)
+    private static StoredSample ReadStored(DbDataReader r, int o)
    {
        var value = ToValue(
            QuestDbConnection.ReadKind(r, o + 1),
@@ -635,6 +646,12 @@ public sealed class QuestDbHistorianDataSource : IHistorianDataSource
        return StoredSample.FromStored(QuestDbConnection.ReadUtc(r, o), value, status);
    }

+    /// <summary>
+    ///     <see cref="ReadStored"/> for an optional picked sample: a NULL <c>ts</c> means the row carries no such sample
+    ///     (live-gate 8 F1), so the result is null rather than an <see cref="InvalidCastException"/>.
+    /// </summary>
+    private static StoredSample? ReadStoredOrNull(DbDataReader r, int o) => r.IsDBNull(o) ? null : ReadStored(r, o);
+
    /// <summary>
    ///     Rebuilds a value from its stored columns via the shared <see cref="SampleColumnMapper.FromColumns"/>, after the
    ///     RC2 repair: QuestDB reads a <c>LONG</c> holding <see cref="long.MinValue"/> back as NULL, so an Int64 row with