test: pin whole-query forwarding; name the query when binding fails

The non-mixed ratio test now requires forwarding with no maintained state,
a binding failure names its query in the candidate error, and the metric
name follows the left side of and/unless.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: zzylol

control_plane/src/physical/compiler.rs

@@ -2427,7 +2427,10 @@ impl DeploymentPlanCompiler {
                         query_node_bindings.retain(|(index, _), _| *index != query_index);
                         Ok(exact_query_entry(query, canonical.clone(), instant))
                     }
-                    other => other,
+                    other => other.map_err(|error| CompileError::Query {
+                        query_id: query.query_id.clone(),
+                        reason: error.to_string(),
+                    }),
                 }
             }?;
             if frontend == QueryFrontend::MetricsQl {
@@ -5135,18 +5138,11 @@ pub(crate) mod tests {
             .compile_promql(workload, environment(10_000))
             .unwrap();
         let entry = plan.query_plan.lookup(query).unwrap();
-        if entry.materialization_bindings().is_empty() {
-            assert!(matches!(
-                &entry.nodes[&entry.root],
-                crate::query_plan::QueryPlanNode::ExactFallback { .. }
-            ));
-            assert!(plan.precompute_plan.materializations.is_empty());
-        } else {
-            assert!(matches!(
-                &entry.nodes[&entry.root],
-                crate::query_plan::QueryPlanNode::PhysicalFragment { .. }
-            ));
-        }
+        assert!(matches!(
+            &entry.nodes[&entry.root],
+            crate::query_plan::QueryPlanNode::ExactFallback { .. }
+        ));
+        assert!(plan.precompute_plan.materializations.is_empty());
     }
 
     // avg_over_time divides two per-series readouts. Planner does not yet

control_plane/src/query_plan.rs

@@ -680,10 +680,12 @@ where
 
 /// Does PromQL keep `__name__` on this query's result series? Only a series
 /// selector keeps it, through ordering, selection, filtering, relabeling,
-/// subqueries and `first_`/`last_over_time`; other functions, aggregations and
-/// arithmetic drop it.
+/// subqueries, `first_`/`last_over_time` and the left side of `and`/`unless`;
+/// other functions, aggregations and arithmetic drop it. A comparison keeps it
+/// unless it has `bool`, which the IR does not record; Planner compiles no
+/// comparison, so the rule treats them as dropping it.
 pub fn result_keeps_metric_name(expr: &planner_types::pre_asap::QueryExpr) -> bool {
-    use planner_types::pre_asap::{AggIntent, QueryExpr};
+    use planner_types::pre_asap::{AggIntent, BinaryOpKind, PromQLVectorSetOpKind, QueryExpr};
     match expr {
         QueryExpr::Scan { .. } => true,
         QueryExpr::TimeRange { child, .. }
@@ -694,6 +696,11 @@ pub fn result_keeps_metric_name(expr: &planner_types::pre_asap::QueryExpr) -> bo
         | QueryExpr::PromqlSeriesSample { child, .. }
         | QueryExpr::PromqlRelabel { child, .. }
         | QueryExpr::PromqlSubquery { child, .. } => result_keeps_metric_name(child),
+        QueryExpr::BinaryOp {
+            op: BinaryOpKind::Set(PromQLVectorSetOpKind::And | PromQLVectorSetOpKind::Unless),
+            lhs,
+            ..
+        } => result_keeps_metric_name(lhs),
         QueryExpr::Aggregate {
             child, measures, ..
         } if matches!(
@@ -1213,6 +1220,32 @@ mod tests {
         compile_query_computation(&temporal).unwrap();
     }
 
+    // PromQL keeps `__name__` only on selections of a series selector.
+    #[test]
+    fn metric_name_follows_promql_result_rules() {
+        for (query, keeps) in [
+            ("m", true),
+            ("m offset 5m", true),
+            ("sort(m)", true),
+            ("topk(2, m)", true),
+            ("last_over_time(m[5m])", true),
+            ("m and n", true),
+            ("rate(m[5m])", false),
+            ("quantile_over_time(0.5, m[5m])", false),
+            ("m * 2", false),
+            ("sum by (job) (m)", false),
+            ("topk(2, rate(m[5m]))", false),
+            ("max_over_time(rate(m[1m])[5m:1m])", false),
+        ] {
+            let expr = crate::query_parser::parse_query_expr_canonical(
+                query,
+                planner_types::types::AccuracyTarget::Exact,
+            )
+            .unwrap();
+            assert_eq!(result_keeps_metric_name(&expr), keeps, "{query}");
+        }
+    }
+
     #[test]
     fn canonical_identity_ignores_formatting() {
         assert_eq!(