chore: Remove redundant DSL::AGG::Unique (#27718)

Author: ritchie46

crates/polars-plan/dsl-schema-hashes.json

@@ -1,6 +1,6 @@
 {
   "AExprSorted": "aa1099889c36978b22cc2c63dd26ee97581eb5f9e09a6e4f715d972d0cdad2c2",
-  "AggExpr": "325a77601773d7ff40afe0dff48f8439116051d34555cf3830c831f74b551016",
+  "AggExpr": "48b4816ce36567b3cf34c359b11fc8265f1bddc0f5b68e23f5981305b5239e7b",
   "AnonymousColumnsUdf": "5bbddd4f899afa592c318b20bb8d0bdfe2877fa5bf1a63d9cd0da908ac3aec0e",
   "AnyValue": "2e8929b09f136470ab8b3f200cd05b0e7c167162a3505c84ebd2a7e3da851403",
   "ArrayDataTypeFunction": "c6089e74d6b54ea7576f21b0bf7d449d60f091243565d245188126f0cd7f1bf6",

crates/polars-plan/src/dsl/expr/mod.rs

@@ -6,7 +6,6 @@ use std::hash::{Hash, Hasher};
 pub use anonymous::*;
 use bytes::Bytes;
 pub use datatype_fn::*;
-use polars_compute::rolling::QuantileMethod;
 use polars_core::chunked_array::cast::CastOptions;
 use polars_core::error::feature_gated;
 use polars_core::prelude::*;
@@ -49,12 +48,6 @@ pub enum AggExpr {
         input: Arc<Expr>,
         include_nulls: bool,
     },
-    // TODO: remove on next DSL break, deprecated in favor of FunctionExpr::Quantile.
-    Quantile {
-        expr: Arc<Expr>,
-        quantile: Arc<Expr>,
-        method: QuantileMethod,
-    },
     Sum(Arc<Expr>),
     AggGroups(Arc<Expr>),
     Std(Arc<Expr>, u8),

crates/polars-plan/src/dsl/format.rs

@@ -185,7 +185,6 @@ impl fmt::Debug for Expr {
                     } => write!(f, "{input:?}.len()"),
                     Var(expr, _) => write!(f, "{expr:?}.var()"),
                     Std(expr, _) => write!(f, "{expr:?}.std()"),
-                    Quantile { expr, .. } => write!(f, "{expr:?}.quantile()"),
                 }
             },
             Cast {

crates/polars-plan/src/plans/conversion/dsl_to_ir/expr_expansion.rs

@@ -389,26 +389,6 @@ fn expand_expression_rec(
                 },
             )?
         },
-        Expr::Agg(AggExpr::Quantile {
-            expr,
-            quantile,
-            method,
-        }) => {
-            _ = expand_expression_by_combination(
-                &[expr.as_ref().clone(), quantile.as_ref().clone()],
-                ignored_selector_columns,
-                schema,
-                out,
-                opt_flags,
-                |e| {
-                    Expr::Agg(AggExpr::Quantile {
-                        expr: Arc::new(e[0].clone()),
-                        quantile: Arc::new(e[1].clone()),
-                        method: *method,
-                    })
-                },
-            )?
-        },
         Expr::Agg(agg) => {
             _ = match agg {
                 AggExpr::Min {
@@ -576,24 +556,6 @@ fn expand_expression_rec(
                     opt_flags,
                     |e| Expr::Agg(AggExpr::Var(Arc::new(e), *ddof)),
                 )?,
-                AggExpr::Quantile {
-                    expr,
-                    quantile,
-                    method,
-                } => expand_expression_by_combination(
-                    &[expr.as_ref().clone(), quantile.as_ref().clone()],
-                    ignored_selector_columns,
-                    schema,
-                    out,
-                    opt_flags,
-                    |e| {
-                        Expr::Agg(AggExpr::Quantile {
-                            expr: Arc::new(e[0].clone()),
-                            quantile: Arc::new(e[1].clone()),
-                            method: *method,
-                        })
-                    },
-                )?,
             }
         },
         Expr::Ternary {

crates/polars-plan/src/plans/conversion/dsl_to_ir/expr_to_ir.rs

@@ -322,23 +322,6 @@ pub(super) fn to_aexpr_impl(
                         output_name,
                     )
                 },
-                AggExpr::Quantile {
-                    expr,
-                    quantile,
-                    method,
-                } => {
-                    // Quantile was moved out from IRAggExpr as it is multi-input.
-                    let expr = to_expr_ir(owned(expr), ctx)?;
-                    let quantile = to_expr_ir(owned(quantile), ctx)?;
-                    let output_name = quantile.output_name().clone();
-                    let function = IRFunctionExpr::Quantile { method };
-                    let aexpr = AExpr::Function {
-                        input: vec![expr, quantile],
-                        options: function.function_options(),
-                        function,
-                    };
-                    return Ok((ctx.arena.add(aexpr), output_name));
-                },
                 AggExpr::Sum(input) => {
                     let (input, output_name) = to_aexpr_mat_lit_arc!(input)?;
                     (IRAggExpr::Sum(input), output_name)

crates/polars-plan/src/plans/iterator.rs

@@ -53,8 +53,6 @@ macro_rules! push_expr {
                     Item { input, .. } => $push($c, input),
                     Implode { input, .. } => $push($c, input),
                     Count { input, .. } => $push($c, input),
-                    // TODO: shouldn't quantile push the quantile expr as well?
-                    Quantile { expr, .. } => $push($c, expr),
                     Sum(e) => $push($c, e),
                     AggGroups(e) => $push($c, e),
                     Std(e, _) => $push($c, e),

crates/polars-plan/src/plans/visitor/expr.rs

@@ -71,7 +71,6 @@ impl TreeWalker for Expr {
                 Mean(x) => Mean(am(x, f)?),
                 Implode { input, maintain_order } => Implode { input: am(input, f)?, maintain_order },
                 Count { input, include_nulls } => Count { input: am(input, f)?, include_nulls },
-                Quantile { expr, quantile, method: interpol } => Quantile { expr: am(expr, &mut f)?, quantile: am(quantile, f)?, method: interpol },
                 Sum(x) => Sum(am(x, f)?),
                 AggGroups(x) => AggGroups(am(x, f)?),
                 Std(x, ddf) => Std(am(x, f)?, ddf),