refactor: name paired aggregates bivariate

Author: zzylol

crates/asap-aware-mapping/src/query_physical_lowering.rs

@@ -1187,8 +1187,8 @@ fn supports_hash_aggregate(
                     | AggIntent::Avg { .. }
                     | AggIntent::StdDev { .. }
                     | AggIntent::Variance { .. }
-                    | AggIntent::Binary {
-                        op: asap_types::pre_asap::BinaryAggOp::Correlation,
+                    | AggIntent::Bivariate {
+                        op: asap_types::pre_asap::BivariateAggOp::Correlation,
                         ..
                     }
                     | AggIntent::Group
@@ -1451,15 +1451,15 @@ mod tests {
     #[test]
     fn correlation_lowers_to_physical_hash_aggregate() {
         use asap_types::pre_asap::{
-            AggIntent, BinaryAggOp, Column, DataType, QueryExpr, Reduction, Schema, Source,
+            AggIntent, BivariateAggOp, Column, DataType, QueryExpr, Reduction, Schema, Source,
         };
         let source = Source::Table {
             table_ref: "pairs".into(),
         };
         let root = Rc::new(QueryExpr::Aggregate {
             reduction: Reduction::by(vec![]),
-            measures: vec![AggIntent::Binary {
-                op: BinaryAggOp::Correlation,
+            measures: vec![AggIntent::Bivariate {
+                op: BivariateAggOp::Correlation,
                 left: 0,
                 right: 1,
             }],

crates/asap-aware-mapping/src/replacement.rs

@@ -822,7 +822,7 @@ pub(crate) fn implementations_for_with(
         AggIntent::Avg { .. }
         | AggIntent::StdDev { .. }
         | AggIntent::Variance { .. }
-        | AggIntent::Binary { .. } => {
+        | AggIntent::Bivariate { .. } => {
             vec![Implementation::PassThrough]
         }
 
@@ -6067,9 +6067,9 @@ mod tests {
 
     // Correlation must never acquire a single-input sketch or scalar accumulator.
     #[test]
-    fn binary_aggregate_keeps_exact_paired_input() {
-        let intent = AggIntent::Binary {
-            op: asap_types::pre_asap::BinaryAggOp::Correlation,
+    fn bivariate_aggregate_keeps_exact_paired_input() {
+        let intent = AggIntent::Bivariate {
+            op: asap_types::pre_asap::BivariateAggOp::Correlation,
             left: 0,
             right: 1,
         };

crates/frontend-sql/src/sql/mod.rs

@@ -1637,8 +1637,8 @@ fn lower_agg_intent(expr: &Expr) -> Result<AggIntent<ColumnRef>, LoweringError>
                             "corr requires two arguments".into(),
                         ));
                     };
-                    AggIntent::Binary {
-                        op: asap_types::pre_asap::BinaryAggOp::Correlation,
+                    AggIntent::Bivariate {
+                        op: asap_types::pre_asap::BivariateAggOp::Correlation,
                         left: expr_to_group_ref(left)?,
                         right: expr_to_group_ref(right)?,
                     }

…/frontend-sql/tests/binary_aggregates.rs …ontend-sql/tests/bivariate_aggregates.rscrates/frontend-sql/tests/binary_aggregates.rs renamed to crates/frontend-sql/tests/bivariate_aggregates.rs crates/frontend-sql/tests/binary_aggregates.rs renamed to crates/frontend-sql/tests/bivariate_aggregates.rs

@@ -2,7 +2,7 @@
 use std::rc::Rc;
 
 use asap_frontend_sql::{lower_sql, SqlCatalog};
-use asap_types::pre_asap::{AggIntent, BinaryAggOp, Column, DataType, QueryExpr, Schema};
+use asap_types::pre_asap::{AggIntent, BivariateAggOp, Column, DataType, QueryExpr, Schema};
 use asap_types::types::AccuracyTarget;
 
 fn catalog() -> SqlCatalog {
@@ -47,8 +47,8 @@ async fn corr_materializes_both_arguments() {
         let (measures, child) = aggregate(&query);
         assert_eq!(
             measures,
-            &[AggIntent::Binary {
-                op: BinaryAggOp::Correlation,
+            &[AggIntent::Bivariate {
+                op: BivariateAggOp::Correlation,
                 left: 0,
                 right: 1,
             }]
@@ -87,7 +87,7 @@ async fn corr_coexists_with_grouping_having_and_other_measures() {
     let (measures, child) = aggregate(&query);
     let pair = measures
         .iter()
-        .find(|m| matches!(m, AggIntent::Binary { .. }))
+        .find(|m| matches!(m, AggIntent::Bivariate { .. }))
         .unwrap();
     let schema = child.output_schema().unwrap();
     for id in pair.input_cols() {

crates/sql-function-catalog/src/lib.rs

@@ -353,7 +353,7 @@ pub const KNOWN_UNMAPPED_NATIVE_FUNCTIONS: &[&str] = &[
     "bool_and",
     "bool_or",
     // Two-column covariance / regression operations not yet implemented by
-    // `AggIntent::Binary`. Correlation is the first supported operation.
+    // `AggIntent::Bivariate`. Correlation is the first supported operation.
     "covar",
     "covar_pop",
     "covar_samp",

crates/types/src/post_asap/execution_data_state.rs

@@ -1069,11 +1069,11 @@ mod tests {
 
     // Both paired operands must be plain; an unrelated state column is not an input.
     #[test]
-    fn binary_aggregate_checks_both_operand_states() {
+    fn bivariate_aggregate_checks_both_operand_states() {
         let operation = ValueOperation::Exact(ExactOperation::Aggregate {
             reduction: Reduction::by(vec![]),
-            measures: vec![AggIntent::Binary {
-                op: crate::pre_asap::BinaryAggOp::Correlation,
+            measures: vec![AggIntent::Bivariate {
+                op: crate::pre_asap::BivariateAggOp::Correlation,
                 left: 0,
                 right: 1,
             }],

crates/types/src/pre_asap/agg_intent.rs

@@ -41,10 +41,10 @@ use crate::types::AccuracyTarget;
 #[serde(bound(serialize = "C: Serialize", deserialize = "C: Deserialize<'de>"))]
 pub enum AggIntent<C = ColumnId> {
     /// A reduction over paired values from two explicit input columns.
-    /// Operation semantics live in `BinaryAggOp`; both references participate
+    /// Operation semantics live in `BivariateAggOp`; both references participate
     /// in binding and dependency tracking, unlike an opaque extension payload.
-    Binary {
-        op: BinaryAggOp,
+    Bivariate {
+        op: BivariateAggOp,
         left: C,
         right: C,
     },
@@ -292,7 +292,7 @@ pub enum AggIntent<C = ColumnId> {
 /// must define their output type and exact/summary realization explicitly.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum BinaryAggOp {
+pub enum BivariateAggOp {
     /// Pearson correlation over pairs where both inputs are non-null.
     Correlation,
 }
@@ -489,12 +489,12 @@ impl<C: Clone> AggIntent<C> {
     /// An empty list retains the existing implicit sample/row-count convention.
     pub fn input_cols(&self) -> Vec<C> {
         match self {
-            Self::Binary { left, right, .. } => vec![left.clone(), right.clone()],
+            Self::Bivariate { left, right, .. } => vec![left.clone(), right.clone()],
             _ => self.input_col().into_iter().collect(),
         }
     }
 
-    /// The explicit input of a single-column reducer. Binary aggregates,
+    /// The explicit input of a single-column reducer. Bivariate aggregates,
     /// argument-less aggregates, and implicit PromQL sample inputs return `None`.
     /// Use `input_cols` for dependency tracking; this accessor is for consumers
     /// that have already selected a single-column implementation.
@@ -529,8 +529,8 @@ impl<C: Clone> AggIntent<C> {
             AggIntent::Avg { .. } => col("avg", DataType::Float64, false),
             AggIntent::StdDev { .. } => col("stddev", DataType::Float64, false),
             AggIntent::Variance { .. } => col("variance", DataType::Float64, false),
-            AggIntent::Binary { op, .. } => match op {
-                BinaryAggOp::Correlation => col("corr", DataType::Float64, true),
+            AggIntent::Bivariate { op, .. } => match op {
+                BivariateAggOp::Correlation => col("corr", DataType::Float64, true),
             },
             AggIntent::Quantile { q, .. } => col(
                 &format!("quantile_{}", quantile_suffix(*q)),
@@ -656,20 +656,20 @@ pub mod topk {
 
 /// Two instances of this aggregation can be merged
 /// (`agg(A ∪ B) = combine(agg(A), agg(B))`). `Avg` / `StdDev` / `Variance`
-/// and binary correlation need richer partial state than a single value, so
+/// and correlation need richer partial state than a single value, so
 /// their finalized values are not mergeable.
 pub fn agg_is_mergeable(op: &AggIntent) -> bool {
     !matches!(
         op,
         AggIntent::Avg { .. }
             | AggIntent::StdDev { .. }
             | AggIntent::Variance { .. }
-            | AggIntent::Binary { .. }
+            | AggIntent::Bivariate { .. }
     )
 }
 
 /// Whether this op implies `exact_required` — no sketch benefit. The exact
-/// intents include `Sum / Count / Avg / Min / Max` and binary correlation.
+/// intents include `Sum / Count / Avg / Min / Max` and correlation.
 pub fn agg_is_exact(op: &AggIntent) -> bool {
     matches!(
         op,
@@ -678,7 +678,7 @@ pub fn agg_is_exact(op: &AggIntent) -> bool {
             | AggIntent::Avg { .. }
             | AggIntent::Min { .. }
             | AggIntent::Max { .. }
-            | AggIntent::Binary { .. }
+            | AggIntent::Bivariate { .. }
             | AggIntent::Group
             | AggIntent::CountValues { .. }
     )
@@ -735,9 +735,9 @@ mod tests {
 
     // Paired aggregates expose both dependencies but cannot merge final scalar results.
     #[test]
-    fn binary_aggregate_contract() {
-        let intent = AggIntent::Binary {
-            op: BinaryAggOp::Correlation,
+    fn bivariate_aggregate_contract() {
+        let intent = AggIntent::Bivariate {
+            op: BivariateAggOp::Correlation,
             left: 2,
             right: 5,
         };
@@ -749,7 +749,7 @@ mod tests {
         assert_eq!(output.dtype, DataType::Float64);
         assert!(output.nullable);
         let value = serde_json::to_value(&intent).unwrap();
-        assert_eq!(value["kind"], "binary");
+        assert_eq!(value["kind"], "bivariate");
         assert_eq!(value["op"], "correlation");
         assert_eq!(serde_json::from_value::<AggIntent>(value).unwrap(), intent);
     }

crates/types/src/pre_asap/binder.rs

@@ -380,12 +380,12 @@ mod tests {
 
     // Both binary inputs must seed a usage-derived schema before positional resolution.
     #[test]
-    fn binary_inputs_seed_usage_derived_schema() {
-        use crate::pre_asap::{AggIntent, BinaryAggOp, Reduction};
+    fn bivariate_inputs_seed_usage_derived_schema() {
+        use crate::pre_asap::{AggIntent, BivariateAggOp, Reduction};
         let tree = UnresolvedQueryExpr::Aggregate {
             reduction: Reduction::by(vec![]),
-            measures: vec![AggIntent::Binary {
-                op: BinaryAggOp::Correlation,
+            measures: vec![AggIntent::Bivariate {
+                op: BivariateAggOp::Correlation,
                 left: ColumnRef::Named("x".into()),
                 right: ColumnRef::Named("y".into()),
             }],

crates/types/src/pre_asap/mod.rs

@@ -43,7 +43,7 @@ pub mod schema;
 
 pub use agg_intent::{
     agg_accuracy, agg_is_exact, agg_is_mergeable, default_cardinality, default_quantile, AggIntent,
-    BinaryAggOp, MathFunc, TimeFunc,
+    BivariateAggOp, MathFunc, TimeFunc,
 };
 pub use binder::{Binder, SchemaCatalog, UsageDerivedCatalog};
 pub use canonicalize::canonicalize;

crates/types/src/pre_asap/resolve.rs

@@ -518,7 +518,7 @@ fn resolve_agg_intent(
         AggIntent::Count { accuracy } => AggIntent::Count {
             accuracy: accuracy.clone(),
         },
-        AggIntent::Binary { op, left, right } => AggIntent::Binary {
+        AggIntent::Bivariate { op, left, right } => AggIntent::Bivariate {
             op: *op,
             left: resolve_column_ref(left, schema)?,
             right: resolve_column_ref(right, schema)?,
@@ -616,14 +616,14 @@ mod tests {
 
     // Both sides resolve with qualifiers; an unknown right input is an error.
     #[test]
-    fn resolve_binary_aggregate_inputs() {
-        use crate::pre_asap::{BinaryAggOp, Column, DataType};
+    fn resolve_bivariate_aggregate_inputs() {
+        use crate::pre_asap::{BivariateAggOp, Column, DataType};
         let schema = Schema::new(vec![
             Column::new("x", DataType::Float64, true).with_table("a"),
             Column::new("x", DataType::Float64, true).with_table("b"),
         ]);
-        let intent = AggIntent::Binary {
-            op: BinaryAggOp::Correlation,
+        let intent = AggIntent::Bivariate {
+            op: BivariateAggOp::Correlation,
             left: ColumnRef::Qualified {
                 table: "a".into(),
                 name: "x".into(),
@@ -635,14 +635,14 @@ mod tests {
         };
         assert_eq!(
             resolve_agg_intent(&intent, &schema).unwrap(),
-            AggIntent::Binary {
-                op: BinaryAggOp::Correlation,
+            AggIntent::Bivariate {
+                op: BivariateAggOp::Correlation,
                 left: 0,
                 right: 1,
             }
         );
-        let missing = AggIntent::Binary {
-            op: BinaryAggOp::Correlation,
+        let missing = AggIntent::Bivariate {
+            op: BivariateAggOp::Correlation,
             left: ColumnRef::Qualified {
                 table: "a".into(),
                 name: "x".into(),