Fixes in PR

Author: yonatan-sevenai

datafusion/sql/src/unparser/plan.rs

@@ -829,17 +829,40 @@ impl Unparser<'_> {
                     select.already_projected(),
                 )?;
 
-                // If the SubqueryAlias directly wraps a plan that builds its
-                // own SELECT clauses (e.g. Aggregate adds GROUP BY, Window adds
+                // If the (possibly rewritten) inner plan builds its own
+                // SELECT clauses (e.g. Aggregate adds GROUP BY, Window adds
                 // OVER, etc.) and unparse_table_scan_pushdown couldn't reduce it,
                 // we must emit a derived subquery: (SELECT ...) AS alias.
                 // Without this, the recursive handler would merge those clauses
                 // into the outer SELECT, losing the subquery structure entirely.
-                if unparsed_table_scan.is_none()
-                    && Self::requires_derived_subquery(plan_alias.input.as_ref())
+                if unparsed_table_scan.is_none() && Self::requires_derived_subquery(plan)
                 {
+                    // When the dialect does not support column aliases in
+                    // table aliases (e.g. SQLite), inject the aliases into
+                    // the inner projection before wrapping as a derived
+                    // subquery.
+                    if !columns.is_empty()
+                        && !self.dialect.supports_column_alias_in_table_alias()
+                    {
+                        let Ok(rewritten_plan) =
+                            inject_column_aliases_into_subquery(plan.clone(), columns)
+                        else {
+                            return internal_err!(
+                                "Failed to transform SubqueryAlias plan"
+                            );
+                        };
+                        return self.derive(
+                            &rewritten_plan,
+                            relation,
+                            Some(self.new_table_alias(
+                                plan_alias.alias.table().to_string(),
+                                vec![],
+                            )),
+                            false,
+                        );
+                    }
                     return self.derive(
-                        &plan_alias.input,
+                        plan,
                         relation,
                         Some(self.new_table_alias(
                             plan_alias.alias.table().to_string(),

datafusion/sql/tests/cases/plan_to_sql.rs

@@ -2894,6 +2894,20 @@ fn test_json_access_3() {
     );
 }
 
+/// Roundtrip test for a subquery aggregate with column aliases.
+/// Ensures that `subquery_alias_inner_query_and_columns` unwrapping
+/// a Projection -> Aggregate still triggers the derived-subquery path.
+#[test]
+fn roundtrip_subquery_aggregate_with_column_alias() -> Result<(), DataFusionError> {
+    roundtrip_statement_with_dialect_helper!(
+        sql: "SELECT id FROM (SELECT max(j1_id) FROM j1) AS c(id)",
+        parser_dialect: GenericDialect {},
+        unparser_dialect: UnparserDefaultDialect {},
+        expected: @"SELECT c.id FROM (SELECT max(j1.j1_id) FROM j1) AS c (id)",
+    );
+    Ok(())
+}
+
 /// Test that unparsing a manually constructed join with a subquery aggregate
 /// preserves the MAX aggregate function.
 ///