Snowflake Dialect

Author: yonatan-sevenai

datafusion/sql/src/unparser/plan.rs

@@ -318,6 +318,7 @@ impl Unparser<'_> {
                             if is_unnest_col {
                                 return Ok(self.build_flatten_value_select_item(
                                     FLATTEN_DEFAULT_ALIAS,
+                                    None,
                                 ));
                             }
                         }
@@ -423,10 +424,14 @@ impl Unparser<'_> {
                 // The projection generated by the `RecursiveUnnestRewriter` from a UNNEST relation will have
                 // only one expression, which is the placeholder column generated by the rewriter.
                 let unnest_input_type = if p.expr.len() == 1 {
-                    Self::check_unnest_placeholder_with_outer_ref(
-                        &p.expr[0],
-                        self.dialect.unnest_as_lateral_flatten(),
-                    )
+                    Self::check_unnest_placeholder_with_outer_ref(&p.expr[0])
+                } else {
+                    None
+                };
+                // Extract the outermost user alias (e.g. "c1" from `UNNEST(...) AS c1`).
+                // Internal aliases like "UNNEST(...)" are not user aliases.
+                let user_alias = if unnest_input_type.is_some() {
+                    Self::extract_unnest_user_alias(&p.expr[0])
                 } else {
                     None
                 };
@@ -466,8 +471,10 @@ impl Unparser<'_> {
                         relation.flatten(flatten_relation);
 
                         if !select.already_projected() {
-                            let value_expr =
-                                self.build_flatten_value_select_item(&alias_name);
+                            let value_expr = self.build_flatten_value_select_item(
+                                &alias_name,
+                                user_alias.as_deref(),
+                            );
                             select.projection(vec![value_expr]);
                         }
 
@@ -501,8 +508,10 @@ impl Unparser<'_> {
                     flatten.outer(unnest.options.preserve_nulls);
 
                     if !select.already_projected() {
-                        let value_expr =
-                            self.build_flatten_value_select_item(&alias_name);
+                        let value_expr = self.build_flatten_value_select_item(
+                            &alias_name,
+                            user_alias.as_deref(),
+                        );
                         select.projection(vec![value_expr]);
                     }
 
@@ -540,6 +549,7 @@ impl Unparser<'_> {
                 }
                 if self.dialect.unnest_as_table_factor()
                     && unnest_input_type.is_some()
+                    && user_alias.is_none() // Skip if user alias present — fall through to reconstruct_select_statement which preserves aliases
                     && let LogicalPlan::Unnest(unnest) = &p.input.as_ref()
                     && let Some(unnest_relation) =
                         self.try_unnest_to_table_factor_sql(unnest)?
@@ -1241,28 +1251,14 @@ impl Unparser<'_> {
     /// - If the column is not a placeholder column, return [None].
     ///
     /// `outer_ref` is the display result of [Expr::OuterReferenceColumn]
-    /// When `deep_peel` is true, peels through multiple Alias layers to find
-    /// the inner Column. This is needed for Snowflake FLATTEN where user aliases
-    /// (e.g. `AS items`) add extra Alias wrappers around the placeholder column.
-    fn check_unnest_placeholder_with_outer_ref(
-        expr: &Expr,
-        deep_peel: bool,
-    ) -> Option<UnnestInputType> {
-        let inner = match expr {
-            Expr::Alias(Alias { expr, .. }) => {
-                if deep_peel {
-                    // Peel through all Alias layers
-                    let mut e = expr.as_ref();
-                    while let Expr::Alias(Alias { expr: next, .. }) = e {
-                        e = next.as_ref();
-                    }
-                    e
-                } else {
-                    expr.as_ref()
-                }
-            }
-            _ => return None,
-        };
+    fn check_unnest_placeholder_with_outer_ref(expr: &Expr) -> Option<UnnestInputType> {
+        // Peel through all Alias layers to find the inner Column.
+        // The expression may have multiple aliases, e.g.:
+        //   Alias("items", Alias("UNNEST(...)", Column("__unnest_placeholder(...)")))
+        let mut inner = expr;
+        while let Expr::Alias(Alias { expr, .. }) = inner {
+            inner = expr.as_ref();
+        }
         if let Expr::Column(Column { name, .. }) = inner
             && let Some(prefix) = name.strip_prefix(UNNEST_PLACEHOLDER)
         {
@@ -1274,6 +1270,19 @@ impl Unparser<'_> {
         None
     }
 
+    /// Extract the outermost user-provided alias from an unnest expression.
+    /// Returns `None` if the outermost alias is DataFusion's internal display
+    /// name (e.g. `UNNEST(make_array(...))`), or if there is no alias at all.
+    fn extract_unnest_user_alias(expr: &Expr) -> Option<String> {
+        if let Expr::Alias(Alias { name, .. }) = expr {
+            // Internal aliases start with "UNNEST(" — user aliases don't.
+            if !name.starts_with(&format!("{UNNEST_COLUMN_PREFIX}(")) {
+                return Some(name.clone());
+            }
+        }
+        None
+    }
+
     fn try_unnest_to_table_factor_sql(
         &self,
         unnest: &Unnest,
@@ -1305,12 +1314,22 @@ impl Unparser<'_> {
     }
 
     /// Build a `SELECT alias."VALUE"` item for Snowflake FLATTEN output.
-    fn build_flatten_value_select_item(&self, alias_name: &str) -> ast::SelectItem {
+    fn build_flatten_value_select_item(
+        &self,
+        flatten_alias: &str,
+        user_alias: Option<&str>,
+    ) -> ast::SelectItem {
         let compound = ast::Expr::CompoundIdentifier(vec![
-            self.new_ident_without_quote_style(alias_name.to_string()),
+            self.new_ident_without_quote_style(flatten_alias.to_string()),
             Ident::with_quote('"', "VALUE"),
         ]);
-        ast::SelectItem::UnnamedExpr(compound)
+        match user_alias {
+            Some(alias) => ast::SelectItem::ExprWithAlias {
+                expr: compound,
+                alias: self.new_ident_quoted_if_needs(alias.to_string()),
+            },
+            None => ast::SelectItem::UnnamedExpr(compound),
+        }
     }
 
     /// Convert an `Unnest` logical plan node to a `LATERAL FLATTEN(INPUT => expr, ...)`

datafusion/sql/tests/cases/plan_to_sql.rs

@@ -3073,7 +3073,7 @@ fn snowflake_flatten_select_unnest_with_alias() -> Result<(), DataFusionError> {
         sql: "SELECT UNNEST([1,2,3]) as c1",
         parser_dialect: GenericDialect {},
         unparser_dialect: snowflake,
-        expected: @r#"SELECT _unnest."VALUE" FROM LATERAL FLATTEN(INPUT => [1, 2, 3]) AS _unnest"#,
+        expected: @r#"SELECT _unnest."VALUE" AS "c1" FROM LATERAL FLATTEN(INPUT => [1, 2, 3]) AS _unnest"#,
     );
     Ok(())
 }
@@ -3180,7 +3180,7 @@ fn snowflake_flatten_unnest_udf_result() -> Result<(), DataFusionError> {
     let result = unparser.plan_to_sql(&plan)?;
     let actual = result.to_string();
 
-    insta::assert_snapshot!(actual, @r#"SELECT _unnest."VALUE" FROM "j1" CROSS JOIN LATERAL FLATTEN(INPUT => json_get_array("j1"."j1_string")) AS _unnest LIMIT 5"#);
+    insta::assert_snapshot!(actual, @r#"SELECT _unnest."VALUE" AS "items" FROM "j1" CROSS JOIN LATERAL FLATTEN(INPUT => json_get_array("j1"."j1_string")) AS _unnest LIMIT 5"#);
     Ok(())
 }