[zzylol]

Why

ASAPQuery keeps one finest-grain summary per series and answers every grouping of a metric from it: one sketch per series for the quantiles, one per-series sum for a fine and a coarse sum. The joint plan built one copy per query instead. Each query's PromQL scan projects only the labels its own by needs, so per-series summaries holding the same states got different definitions:

• avg by (region) (quantile_over_time(0.99, data[100s])) and avg by (region, service, job) (quantile_over_time(0.9, data[100s])) stored two per-series DDSketch definitions, about 1.6 GB each at ASAPQuery's scale.
• sum by (region, service, job) (sum_over_time(data[W])) and sum by (region) (sum_over_time(data[W])) stored two per-series Sums.

What

In both cases, one finest-grain stored summary now serves several groupings.

• Quantiles: one summary at the estimate level. One per-series DDSketch is stored. Each query estimates its quantile per series from it, keeps the labels it needs, then applies its own avg by G. Sketches are not merged.
• Sums: one summary at the state level. One per-series Sum is stored. Each grouping's sum is computed from the per-series sums (the per-series Sum states combined by group), then finalized.
• Rollups over panes. A rollup Pass 2 candidate is now also built over tumbling panes. Before, Pass 2 never combined the rollup rule with window composition, so a rolled-up plan read its finer build's whole window from raw samples, and every rollup was rejected on a deployment that keeps no raw samples.

How

• Summary-capability rule. It now groups per-series builds whose scans of one metric project different labels. The scans must have no label matchers and the same windows and offsets (the rollup rule's existing same_rows), the builds no filter, and both inputs a $promql_series_identity column. A per-series state is keyed by the series identity, which determines every label, so these builds hold the same states. Besides sketches, the rule now covers per-series exact accumulators read only through FinalizeExactAccumulator.
• The shared build. It is the member whose scan has every member's labels; a group without one is not shared. Every reader of each other member (an estimate for a quantile, a finalization for a sum) is rebuilt over the shared build, followed by a Project that keeps that reader's own columns by name, so the operators above it are unchanged.
• Sign through the Project. A projection of columns now keeps the sample sign of the values below it, so DDSketch's relative bound still carries through avg over a declared non-negative gauge. Only bare column references pass, so no computed value inherits the sign.
• Rollup with panes. After each rollup Pass 2 candidate, its window-composition Pass 2 candidates are listed too.

Key code interfaces added / modified

crates/logical-asap-optimization/src/asap_aware_cse.rs

/// Summary builds the summary-capability rule can make one build. The type stays.
pub struct CapabilitySharingCandidate {
    /// The first member's family: every member builds this sketch algorithm at some
    /// size, or this per-series exact accumulator (read only through finalization).
    pub family: FieldDataType, // was SketchAlgorithm
    /// The summary builds, at least two, not all equal (in size or in projected labels).
    pub members: Vec<Rc<OperatorNode>>, // unchanged
}

Usage (the tests quantile_queries_with_different_groupings_share_one_per_series_sketch and fine_and_coarse_sums_store_one_sum):

// Three quantile queries over one metric and window, every 10 s, relative 0.05,
// over six series of a non-negative gauge, on a deployment that keeps no raw samples.
let plan_json = jointly_planned(&[
    "avg by (region) (quantile_over_time(0.99, data[100s]))",
    "avg by (region, service, job) (quantile_over_time(0.9, data[100s]))",
    "avg by (service) (quantile_over_time(0.5, data[100s]))",
], RELATIVE_0_05).await;
// Stage 1's capability rule shares the per-series DDSketch over the scan with
// job, region and service; Stage 3 selects it, panes built at ingestion.
assert_eq!(stored_definitions(&plan, "DDSketch").len(), 1);   // was 3
// Fine and coarse sums: one per-series Sum serves both group sums.
assert_eq!(stored_definitions(&sums_plan, "\"Sum\"").len(), 1); // was 2
// Executed from the stored panes, every answer equals query_time_reference.

Before this PR

• The three quantile queries stored 3 DDSketch definitions.
• The two sums stored 2 Sum definitions.
• No rollup candidate was built over panes.

After this PR

• The three quantile queries store 1 DDSketch definition.
• The two sums store 1 Sum definition.
• Rolled-up plans over panes are offered and priced.

Verification

Tests written first.

• planner/tests/runtime_install.rs:
  • quantile_queries_with_different_groupings_share_one_per_series_sketch failed on main with 3 DDSketch definitions.
  • fine_and_coarse_sums_store_one_sum failed on main with 2 Sum definitions.
  • Both now pass. They execute the plan from stored panes, and every answer equals query_time_reference (2, 6 and 3 answers for the quantile queries; 6 and 2 for the sums).
• logical-asap-optimization a_rollup_is_also_built_over_tumbling_panes: some Stage 1 candidate of the sum pair both rolls up and builds panes. It failed without the rollup change.

Added in review.

• per_series_answers_beside_a_grouping_share_one_state_and_answer_as_the_reference: topk(2, sum_over_time(...)) beside sum by (region), and a per-series quantile_over_time beside avg by (region). Each stores one per-series state, and every answer, including the top-k series' labels, equals the query-time reference.
• The reuse_rules execution test now expands pane chains and feeds each raw TimeRange the samples in its own window, so the paned rollup candidate is executed and compared, not skipped.

Existing tests updated to the shared plans.

• Forced-plan tests from InstallablePlan stores only raw-sample panes; describe every stored summary #781. sum by (job) beside sum by (job, instance) is now two group sums built from one stored per-series sum (renamed group_sums_from_one_stored_per_series_sum_are_listed_and_built). The cross-series maximum now shares its per-series maxima with the per-series query.
• fix(logical): a quantile of merged panes keeps its samples' sign, so pane DDSketches compose through avg #795 DDSketch-panes tests. The declared-gauge test also checks that one DDSketch definition is stored. The KLL choices of that query are discarded by main's per-query check, not by this PR: an average of KLL quantiles has no relative bound, so the query planned alone fails with NoAccuracyGuarantee, and the exhaustive search rejects the KLL candidates for the same reason.

Commands. cargo test --workspace --locked, after rebasing onto main: all test binaries passed. Under the current speed-first policy, clippy was not run.

Limitations and follow-up.

• Rollup plan not selected in the test. On the sum pair, Stage 3 selects the shared per-series Sum, not the paned rollup. With no group-count declaration, the cost model assumes 100 groups for every by (...) reduction at ingestion (DEFAULT_GROUP_COUNT), even over 6 series, so the rollup's finer build prices higher. Follow-up: cap the assumed group count at the declared series count.
• Sharing needs a label superset. One member's scan must have every member's labels (true for the ASAPQuery workloads). Queries whose labels are not nested, for example by (region) and by (job) alone, still get separate builds; sharing them would need a scan with the union of the labels. Scans with label matchers are not grouped.
• Pass 2 candidate count. Each rollup Pass 2 candidate is now followed by its window-composition candidates, so the two rules' counts multiply; each rule keeps its own cap, but the product is not capped.