Fix: common_sub_expression_eliminate optimizer rule failed

Common_sub_expression_eliminate rule failed with error:
`SchemaError(FieldNotFound {field: <name>}, valid_fields: []})`
due to the schema being changed by the second application of
`find_common_exprs`.

Used NamePreserver mechanism to restore original schema name and
generate Projection with original names at the end of
aggregate optimization.

Jira: TNTP-996

Author: Col-Waltz

datafusion/optimizer/src/common_subexpr_eliminate.rs

@@ -527,6 +527,19 @@ impl CommonSubexprEliminate {
                         } => {
                             let rewritten_aggr_expr = new_exprs_list.pop().unwrap();
                             let new_aggr_expr = original_exprs_list.pop().unwrap();
+                            let saved_names = if let Some(aggr_expr) = aggr_expr {
+                                let name_perserver = NamePreserver::new_for_projection();
+                                aggr_expr
+                                    .iter()
+                                    .map(|expr| Some(name_perserver.save(expr)))
+                                    .collect::<Vec<_>>()
+                            } else {
+                                new_aggr_expr
+                                    .clone()
+                                    .into_iter()
+                                    .map(|_| None)
+                                    .collect::<Vec<_>>()
+                            };
 
                             let mut agg_exprs = common_exprs
                                 .into_iter()
@@ -542,10 +555,19 @@ impl CommonSubexprEliminate {
                                     &mut proj_exprs,
                                 )?
                             }
-                            for (expr_rewritten, expr_orig) in
-                                rewritten_aggr_expr.into_iter().zip(new_aggr_expr)
+                            for ((expr_rewritten, expr_orig), saved_name) in
+                                rewritten_aggr_expr
+                                    .into_iter()
+                                    .zip(new_aggr_expr)
+                                    .zip(saved_names)
                             {
                                 if expr_rewritten == expr_orig {
+                                    let expr_rewritten =
+                                        if let Some(saved_name) = saved_name {
+                                            saved_name.restore(expr_rewritten)
+                                        } else {
+                                            expr_rewritten
+                                        };
                                     if let Expr::Alias(Alias { expr, name, .. }) =
                                         expr_rewritten
                                     {

datafusion/sqllogictest/test_files/aggregate.slt

@@ -575,6 +575,31 @@ SELECT c2, var_samp(c12) FILTER (WHERE c12 > 0.90) FROM aggregate_test_100 GROUP
 4 NULL
 5 0.000269544643
 
+statement ok
+CREATE TABLE t(
+  a DOUBLE,
+  b BIGINT,
+  c INT
+) AS VALUES
+(1.0, 10, -5),
+(2.0, 20, -5),
+(3.0, 20, 4)
+
+# Common sub-expression elimination.
+query III
+WITH s AS (
+    SELECT
+        COUNT(a) FILTER (WHERE (b * b) - 3600 <= b),
+	COUNT(a) FILTER (WHERE (b * b) - 3000 <= b AND (c >= 0)),
+	COUNT(a) FILTER (WHERE (b * b) - 3000 <= b AND (c >= 0) AND (c >= 0))
+    FROM t
+) SELECT * FROM s
+----
+3 1 1
+
+statement ok
+DROP TABLE t
+
 # Restore the default dialect
 statement ok
 set datafusion.sql_parser.dialect = 'Generic';