Apache DataFusion SQL Query Engine
fix: preserve computed names in derived SQL projections (#25521)
Stefan Wang2424daeb18d5
diff --git a/datafusion/sql/src/unparser/ast.rs b/datafusion/sql/src/unparser/ast.rsindex c335d3ee4c..38b51afe3e 100644--- a/datafusion/sql/src/unparser/ast.rs+++ b/datafusion/sql/src/unparser/ast.rs@@ -677,6 +677,7 @@ pub struct DerivedRelationBuilder {lateral: Option<bool>,subquery: Option<Box<ast::Query>>,alias: Option<ast::TableAlias>,+ projection_names: Vec<ast::Ident>,}impl DerivedRelationBuilder {@@ -692,18 +693,49 @@ impl DerivedRelationBuilder {self.alias = value;self}+ pub(super) fn projection_names(&mut self, value: Vec<ast::Ident>) -> &mut Self {+ self.projection_names = value;+ self+ }fn build(&self) -> Result<ast::TableFactor, BuilderError> {+ let mut subquery = match self.subquery {+ Some(ref value) => value.clone(),+ None => {+ return Err(Into::into(UninitializedFieldError::from("subquery")));+ }+ };+ if self+ .alias+ .as_ref()+ .is_none_or(|alias| alias.columns.is_empty())+ && let ast::SetExpr::Select(select) = subquery.body.as_mut()+ && select.projection.len() == self.projection_names.len()+ {+ for (item, alias) in select.projection.iter_mut().zip(&self.projection_names)+ {+ if let ast::SelectItem::UnnamedExpr(expr) = item {+ let preserves_name = match expr {+ ast::Expr::Identifier(name) => name.value == alias.value,+ ast::Expr::CompoundIdentifier(names) => {+ names.last().is_some_and(|name| name.value == alias.value)+ }+ _ => false,+ };+ if !preserves_name {+ *item = ast::SelectItem::ExprWithAlias {+ expr: expr.clone(),+ alias: alias.clone(),+ };+ }+ }+ }+ }Ok(ast::TableFactor::Derived {lateral: match self.lateral {Some(ref value) => *value,None => return Err(Into::into(UninitializedFieldError::from("lateral"))),},- subquery: match self.subquery {- Some(ref value) => value.clone(),- None => {- return Err(Into::into(UninitializedFieldError::from("subquery")));- }- },+ subquery,alias: self.alias.clone(),sample: None,})@@ -713,6 +745,7 @@ impl DerivedRelationBuilder {lateral: Default::default(),subquery: Default::default(),alias: Default::default(),+ projection_names: Default::default(),}}}diff --git a/datafusion/sql/src/unparser/plan.rs b/datafusion/sql/src/unparser/plan.rsindex 69babae4e0..70a802629c 100644--- a/datafusion/sql/src/unparser/plan.rs+++ b/datafusion/sql/src/unparser/plan.rs@@ -593,7 +593,18 @@ impl Unparser<'_> {alias: Option<ast::TableAlias>,lateral: bool,) -> Result<()> {+ let preserve_names = matches!(plan, LogicalPlan::Projection(_))+ && alias.as_ref().is_none_or(|alias| alias.columns.is_empty());let mut derived_builder = DerivedRelationBuilder::default();+ if preserve_names {+ derived_builder.projection_names(+ plan.schema()+ .fields()+ .iter()+ .map(|field| self.column_alias_to_sql(field.name()))+ .collect::<Result<Vec<_>>>()?,+ );+ }derived_builder.lateral(lateral).alias(alias).subquery({let inner_statement = self.plan_to_sql(plan)?;if let ast::Statement::Query(inner_query) = inner_statement {@@ -2693,18 +2704,9 @@ impl Unparser<'_> {Expr::Alias(Alias { expr, name, .. }) => {let inner = self.expr_to_sql(expr)?;- // Determine the alias name to use- let col_name = if let Some(rewritten_name) =- self.dialect.col_alias_overrides(name)?- {- rewritten_name.to_string()- } else {- name.to_string()- };-Ok(ast::SelectItem::ExprWithAlias {expr: inner,- alias: self.new_ident_quoted_if_needs(col_name),+ alias: self.column_alias_to_sql(name)?,})}_ => {@@ -2715,6 +2717,14 @@ impl Unparser<'_> {}}+ fn column_alias_to_sql(&self, name: &str) -> Result<Ident> {+ let name = self+ .dialect+ .col_alias_overrides(name)?+ .unwrap_or_else(|| name.to_string());+ Ok(self.new_ident_quoted_if_needs(name))+ }+fn sorts_to_sql(&self, sort_exprs: &[SortExpr]) -> Result<OrderByKind> {Ok(OrderByKind::Expressions(sort_exprsdiff --git a/datafusion/sql/tests/cases/plan_to_sql.rs b/datafusion/sql/tests/cases/plan_to_sql.rsindex 191425416c..de22321327 100644--- a/datafusion/sql/tests/cases/plan_to_sql.rs+++ b/datafusion/sql/tests/cases/plan_to_sql.rs@@ -17,6 +17,7 @@use arrow::datatypes::{DataType, Field, Schema};+use datafusion_common::tree_node::{Transformed, TransformedResult};use datafusion_common::{Column, DFSchema, DFSchemaRef, DataFusionError, Result, TableReference,assert_contains,@@ -111,6 +112,25 @@ fn roundtrip_expr(table: TableReference, sql: &str) -> Result<String> {Ok(ast.to_string())}+fn remove_column_self_aliases(plan: LogicalPlan) -> Result<LogicalPlan> {+ plan.transform_up_with_subqueries(|plan| {+ plan.map_expressions(|expr| {+ if let Expr::Alias(alias) = &expr+ && alias.relation.is_none()+ && alias.metadata.is_none()+ && let Expr::Column(column) = alias.expr.as_ref()+ && column.relation.is_none()+ && column.name == alias.name+ {+ Ok(Transformed::yes(*alias.expr.clone()))+ } else {+ Ok(Transformed::no(expr))+ }+ })+ })+ .data()+}+#[test]fn roundtrip_statement() -> Result<()> {let tests: Vec<&str> = vec![@@ -254,7 +274,11 @@ fn roundtrip_statement() -> Result<()> {.sql_statement_to_plan(roundtrip_statement.clone()).unwrap();- assert_eq!(plan, plan_roundtrip);+ // Explicit output names can add unqualified self-aliases without changing the plan's meaning.+ assert_eq!(+ remove_column_self_aliases(plan)?,+ remove_column_self_aliases(plan_roundtrip)?,+ );}Ok(())@@ -392,6 +416,37 @@ fn roundtrip_statement_with_dialect_4() -> Result<(), DataFusionError> {Ok(())}+#[test]+fn unparse_preserves_derived_aggregate_output_name() -> Result<()> {+ let schema = Schema::new(vec![Field::new("j1_id", DataType::Int32, false)]);+ let aggregate = sum(col("j1.j1_id"));+ let output = Expr::Column(Column::from_name(aggregate.schema_name().to_string()));+ let plan = table_scan(Some("j1"), &schema, None)?+ .aggregate(Vec::<Expr>::new(), vec![aggregate])?+ .project(vec![output.clone().alias("visible"), output.clone()])?+ .project(vec![output])?+ .build()?;++ let sql = Unparser::new(&UnparserPostgreSqlDialect {})+ .plan_to_sql(&plan)?+ .to_string();+ println!("UNPARSED_SQL={sql}");+ assert_snapshot!(+ sql,+ @r#"SELECT "sum(j1.j1_id)" FROM (SELECT sum("j1"."j1_id") AS "visible", sum("j1"."j1_id") AS "sum(j1.j1_id)" FROM "j1") AS "derived_projection""#+ );++ let sql = Unparser::new(&BigQueryDialect {})+ .plan_to_sql(&plan)?+ .to_string();+ println!("BIGQUERY_SQL={sql}");+ assert_snapshot!(+ sql,+ @r#"SELECT `sum_40j1_46j1_id_41` FROM (SELECT sum(`j1`.`j1_id`) AS `visible`, sum(`j1`.`j1_id`) AS `sum_40j1_46j1_id_41` FROM `j1`)"#+ );+ Ok(())+}+#[test]fn roundtrip_rebases_derived_projection_references() -> Result<(), DataFusionError> {roundtrip_statement_with_dialect_helper!(