From c4cc75fc78b1d61c0605b944cf16b2dcc7a7c81a Mon Sep 17 00:00:00 2001
From: xudong963 <wxd963996380@gmail.com>
Date: Tue, 22 Jul 2025 19:31:48 +0800
Subject: [PATCH] save

---
 datafusion/expr/src/logical_plan/builder.rs | 17 +++++++++++++----
 datafusion/sql/src/utils.rs                 | 21 ++++++++++++++-------
 2 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/datafusion/expr/src/logical_plan/builder.rs b/datafusion/expr/src/logical_plan/builder.rs
index 1ab5ffa75842..15d89a5fb13b 100644
--- a/datafusion/expr/src/logical_plan/builder.rs
+++ b/datafusion/expr/src/logical_plan/builder.rs
@@ -2090,10 +2090,19 @@ pub fn unnest(input: LogicalPlan, columns: Vec<Column>) -> Result<LogicalPlan> {
 pub fn get_struct_unnested_columns(
     col_name: &String,
     inner_fields: &Fields,
-) -> Vec<Column> {
+    alias: Option<&String>,
+) -> Vec<Expr> {
     inner_fields
         .iter()
-        .map(|f| Column::from_name(format!("{}.{}", col_name, f.name())))
+        .map(|f| {
+            let col =
+                Expr::Column(Column::from_name(format!("{}.{}", col_name, f.name())));
+            if let Some(alias_name) = alias {
+                col.alias(format!("{alias_name}.{}", f.name()))
+            } else {
+                col
+            }
+        })
         .collect()
 }
 
@@ -2660,12 +2669,12 @@ mod tests {
 
         assert_snapshot!(plan, @r"
         Union
-          Cross Join: 
+          Cross Join:
             SubqueryAlias: left
               Values: (Int32(1))
             SubqueryAlias: right
               Values: (Int32(1))
-          Cross Join: 
+          Cross Join:
             SubqueryAlias: left
               Values: (Int32(1))
             SubqueryAlias: right
diff --git a/datafusion/sql/src/utils.rs b/datafusion/sql/src/utils.rs
index 52832e1324be..af447d99ac24 100644
--- a/datafusion/sql/src/utils.rs
+++ b/datafusion/sql/src/utils.rs
@@ -415,6 +415,12 @@ impl RecursiveUnnestRewriter<'_> {
 
         match data_type {
             DataType::Struct(inner_fields) => {
+                let mut alias_name = None;
+                if let Expr::Alias(Alias { name, .. }) = self.root_expr {
+                    alias_name = Some(name);
+                }
+
+                dbg!(alias_name.clone());
                 if !struct_allowed {
                     return internal_err!("unnest on struct can only be applied at the root level of select expression");
                 }
@@ -424,12 +430,11 @@ impl RecursiveUnnestRewriter<'_> {
                 );
                 self.columns_unnestings
                     .insert(Column::from_name(placeholder_name.clone()), None);
-                Ok(
-                    get_struct_unnested_columns(&placeholder_name, &inner_fields)
-                        .into_iter()
-                        .map(Expr::Column)
-                        .collect(),
-                )
+                Ok(get_struct_unnested_columns(
+                    &placeholder_name,
+                    &inner_fields,
+                    alias_name,
+                ))
             }
             DataType::List(_)
             | DataType::FixedSizeList(_, _)
@@ -554,7 +559,9 @@ impl TreeNodeRewriter for RecursiveUnnestRewriter<'_> {
                 // instead of unnest(struct_arr_col, depth = 2)
 
                 let unnest_recursion = unnest_stack.len();
-                let struct_allowed = (&expr == self.root_expr) && unnest_recursion == 1;
+                let struct_allowed = ((&expr == self.root_expr)
+                    || (matches!(self.root_expr, Expr::Alias(Alias { expr: inner, .. }) if inner.as_ref() == &expr)))
+                    && unnest_recursion == 1;
 
                 let mut transformed_exprs = self.transform(
                     unnest_recursion,