feat: per-Capability sketch reducer — warm-tier query evaluator

[zzylol]

Summary

Replaces the all-Hit CapabilityMiss fall-through in the warm-tier classify hook (added in #122) with real sketch evaluation off SketchIndex.query_range. Queries answerable from sketches now skip the archive forward entirely.

This is the last substantive piece of the centralized-sid refactor before MVP-demo end-to-end testing. With this in place, B0 / B1 / ASAP arms can answer the same PromQL on the same metric name and the demo's "ASAP gives same answer with less bandwidth" claim becomes testable.

Depends on

This PR will rebase onto #123 (datafusion removal + SketchIndex into sketch_db) once that merges. The rebase changes are mechanical: import paths crate::stores::sketch_index::* → crate::stores::sketch_db::sketch_index::* at two sites in sketch_reducer.rs + one site in tests.rs.

What landed

engines/warm_tier/sketch_reducer.rs (559 lines)

pub struct SketchReducer<'a> {
    pub index: &'a SketchIndex,
}

pub enum WarmTierError {
    UnsupportedFunction(String),
    UnsupportedCapability { function: String, capability: Capability },
    DeserializeFailure { sid: u64, encoding: SketchEncoding, reason: String },
    NoData { metric_name: String },
}

pub struct WarmTierResult {
    pub series: Vec<(BTreeMap<String,String>, Vec<(i64, f64)>)>,
}

impl<'a> SketchReducer<'a> {
    pub fn evaluate(&self, sids: &[u64], function_name: &str,
                    function_args: &[f64], t0_ms: u64, t1_ms: u64)
        -> Result<WarmTierResult, WarmTierError>;
}

Per-Capability dispatch

Capability	Function	Sketch lib calls
QuantileApprox(DDSketch)	quantile_over_time, histogram_quantile	DdSketch::from_raw + DdSketch::quantile(q)
QuantileApprox(Kll)	quantile_over_time, histogram_quantile	KllSketch::new(k) + replay items + quantile(q) (matches precompute path's lossy proto reconstruction)
CardinalityApprox	count_distinct_over_time, cardinality_estimate	HllSketch::from_raw + estimate()
FrequencyTopk(CountMin/CountSketch)	topk, topk_over_time	TODO — surfaced as UnsupportedCapability for now (CMS-with-heap needs a SketchKindHandle::CmsWithHeap variant)

Decoders cover ProtoFull always and MsgpackFull for DD/KLL/HLL. Delta encodings (ProtoDelta / MsgpackDelta) surface as DeserializeFailure because applying a delta requires the prior base snapshot, which query_range doesn't stitch yet.

engines/warm_tier/promql_extract.rs (159 lines)

extract_promql_call(query) -> Option<PromqlCall> walks the promql_parser AST and returns the outermost call's function name + leading numeric args:

• Call(func, args) → ("quantile_over_time", [0.99]) etc.
• Aggregate(op, param, expr) → ("topk", [5.0]) etc.
• Paren / Subquery unwrap.
• Bare VectorSelector / MatrixSelector → func = "" (CapabilityMiss).
• Binary ops, nested calls beyond outermost → None (CapabilityMiss).

engines/simple/engine.rs hook

The Phase 5 warm-tier classify branch (#122) now does:

if all_hit {
    let reducer = SketchReducer::new(idx);
    match reducer.evaluate(&candidates, &fn_name, &fn_args, t0_ms, t1_ms) {
        Ok(result) => return Ok(warm_tier_result_to_query_result(result)),
        Err(WarmTierError::UnsupportedFunction(_)
            | WarmTierError::UnsupportedCapability { .. }
            | WarmTierError::DeserializeFailure { .. }
            | WarmTierError::NoData { .. }) => {
            return Err(EngineError::CapabilityMiss(SketchWarmTier, ...));
        }
    }
}

Mismatch / decode failure / no data → CapabilityMiss → archive failover (existing EngineRouter behavior).

Build + test

• cargo build --release -p query_engine_rust — clean (only pre-existing warnings on the controller crate).
• 14 new tests pass:
  • DDSketch quantile_over_time (3 windows, ±5% rel-error)
  • KLL quantile_over_time (1 window, exact for ≤ 50 items)
  • HLL cardinality_estimate (1000 distinct, 5σ envelope)
  • Capability-mismatch (topk on QuantileApprox) → UnsupportedCapability
  • Empty / no-data → NoData
  • Unsupported function (rate) → UnsupportedFunction
  • Decode failure (garbage proto) → DeserializeFailure
  • Multi-series (2 distinct host= values, 2 result series)
  • 5 promql_extract tests covering quantile/histogram/topk/bare/binary
• PR feat: wire SeriesIdResolver + SketchIndex into OTLP receive + query (Phase 4+5+6 finish) #122's 3 warm_tier_classify_tests still green.
• Overall cargo test --release -p query_engine_rust --lib: 915 passed, 33 failed. The 33 failures are all pre-existing (28 datafusion tests going away in cleanup: remove datafusion + integrate SketchIndex into sketch_db #123, 2 schema_timeline_dispatch flakes, 2 persistence integration, 1 async-flaky e2e_feedback_loop_tests).

Follow-ups

• Per-window merge for *_over_time queries within [t0, t1] (today: one scalar per window_end_unix_ms).
• FrequencyTopk + topk(k, foo) — needs CmsWithHeap SketchKindHandle variant. CMS / CountSketch decoders are stubbed under #[allow(dead_code)] for trivial future-merge.
• Delta encoding stitching — needs base-snapshot lookup.
• Hybrid stitch (warm [t0..t1'] + archive [t1'..t1]) — needs QueryResult to carry timestamp coverage metadata.
• Time bounds in QueryEngine::execute — trait surface doesn't pass (t0, t1); today the dispatch uses [now - 5min, now]. Range-query path should call SketchReducer::evaluate directly with its own bounds.

🤖 Generated with Claude Code