Remove comment

Author: Vedin

datafusion/optimizer/src/common_subexpr_eliminate.rs

@@ -220,10 +220,6 @@ impl CommonSubexprEliminate {
                     .into_iter()
                     .zip(window_schemas)
                     .try_rfold(new_input, |plan, (new_window_expr, schema)| {
-                        // Rebuilding with the preserved schema to keep column names stable. 
-                        // If that fails (e.g., due to expr/schema mismatch
-                        // from earlier rewrites), fall back to rebuilding the schema
-                        // from the expressions directly.
                         match Window::try_new_with_schema(
                             new_window_expr.clone(),
                             Arc::new(plan.clone()),
@@ -731,7 +727,6 @@ impl CSEController for ExprCSEController<'_> {
     }
 }
 
-
 impl Default for CommonSubexprEliminate {
     fn default() -> Self {
         Self::new()
@@ -804,11 +799,13 @@ mod test {
 
     use arrow::datatypes::{DataType, Field, Schema, SchemaRef};
     use datafusion_expr::logical_plan::{table_scan, JoinType};
+    use datafusion_expr::window_frame::WindowFrame;
     use datafusion_expr::{
-        grouping_set, is_null, not, AccumulatorFactoryFunction, AggregateUDF, ColumnarValue, ScalarFunctionArgs, ScalarUDF, ScalarUDFImpl, Signature, SimpleAggregateUDF, TableSource, Volatility
+        grouping_set, is_null, not, AccumulatorFactoryFunction, AggregateUDF,
+        ColumnarValue, ScalarFunctionArgs, ScalarUDF, ScalarUDFImpl, Signature,
+        SimpleAggregateUDF, TableSource, Volatility,
     };
     use datafusion_expr::{lit, logical_plan::builder::LogicalPlanBuilder};
-    use datafusion_expr::window_frame::WindowFrame;
     use datafusion_functions_window::row_number::row_number_udwf;
 
     use super::*;
@@ -1710,9 +1707,9 @@ mod test {
             .filter(Expr::BinaryExpr(BinaryExpr {
                 left: Box::new(wnd),
                 op: Operator::Eq,
-                right: Box::new(Expr::Literal(
-                    datafusion_common::ScalarValue::UInt64(Some(1)),
-                )),
+                right: Box::new(Expr::Literal(datafusion_common::ScalarValue::UInt64(
+                    Some(1),
+                ))),
             }))
             .unwrap()
             .project(vec![col("a"), col("b")])

datafusion/sql/src/select.rs

@@ -219,10 +219,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
             mut select_exprs_post_aggr,
             having_expr_post_aggr,
             mut qualify_expr_post_aggr,
-        ) = if !group_by_exprs
-            .is_empty()
-            || !aggr_exprs.is_empty()
-        {
+        ) = if !group_by_exprs.is_empty() || !aggr_exprs.is_empty() {
             self.aggregate(
                 &base_plan,
                 &select_exprs,
@@ -252,13 +249,14 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
         };
 
         // Process window function
-        let window_search_exprs: Vec<Expr> = if let Some(ref qualify_expr) = qualify_expr_post_aggr {
-            let mut v = select_exprs_post_aggr.clone();
-            v.push(qualify_expr.clone());
-            v
-        } else {
-            select_exprs_post_aggr.clone()
-        };
+        let window_search_exprs: Vec<Expr> =
+            if let Some(ref qualify_expr) = qualify_expr_post_aggr {
+                let mut v = select_exprs_post_aggr.clone();
+                v.push(qualify_expr.clone());
+                v
+            } else {
+                select_exprs_post_aggr.clone()
+            };
         let window_func_exprs = find_window_exprs(&window_search_exprs);
 
         if has_qualify && window_func_exprs.is_empty() {
@@ -280,15 +278,18 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
 
             // Re-write QUALIFY predicate to reference computed window columns
             if let Some(q) = qualify_expr_post_aggr.take() {
-                qualify_expr_post_aggr = Some(rebase_expr(&q, &window_func_exprs, &plan)?);
+                qualify_expr_post_aggr =
+                    Some(rebase_expr(&q, &window_func_exprs, &plan)?);
             }
 
             plan
         };
 
         // Apply QUALIFY filter
         let plan = if let Some(qualify_expr) = qualify_expr_post_aggr {
-            LogicalPlanBuilder::from(plan).filter(qualify_expr)?.build()?
+            LogicalPlanBuilder::from(plan)
+                .filter(qualify_expr)?
+                .build()?
         } else {
             plan
         };