Use qualified aliases to simplify searching DFSchema (apache#12546)

HuSen8891 · Sep 23, 2024 · d73c9d8 · d73c9d8
1 parent 3978e5d
commit d73c9d8
Show file tree

Hide file tree

Showing 3 changed files with 13 additions and 27 deletions.
diff --git a/datafusion/common/src/dfschema.rs b/datafusion/common/src/dfschema.rs
@@ -355,18 +355,7 @@ impl DFSchema {
                 // qualifier and name.
                 (Some(q), Some(field_q)) => q.resolved_eq(field_q) && f.name() == name,
                 // field to lookup is qualified but current field is unqualified.
-                (Some(qq), None) => {
-                    // the original field may now be aliased with a name that matches the
-                    // original qualified name
-                    let column = Column::from_qualified_name(f.name());
-                    match column {
-                        Column {
-                            relation: Some(r),
-                            name: column_name,
-                        } => &r == qq && column_name == name,
-                        _ => false,
-                    }
-                }
+                (Some(_), None) => false,
                 // field to lookup is unqualified, no need to compare qualifier
                 (None, Some(_)) | (None, None) => f.name() == name,
             })

diff --git a/datafusion/optimizer/src/single_distinct_to_groupby.rs b/datafusion/optimizer/src/single_distinct_to_groupby.rs
@@ -22,9 +22,7 @@ use std::sync::Arc;
 use crate::optimizer::ApplyOrder;
 use crate::{OptimizerConfig, OptimizerRule};
 
-use datafusion_common::{
-    internal_err, qualified_name, tree_node::Transformed, DataFusionError, Result,
-};
+use datafusion_common::{internal_err, tree_node::Transformed, DataFusionError, Result};
 use datafusion_expr::builder::project;
 use datafusion_expr::{
     col,
@@ -135,7 +133,7 @@ impl OptimizerRule for SingleDistinctToGroupBy {
                 // alias all original group_by exprs
                 let (mut inner_group_exprs, out_group_expr_with_alias): (
                     Vec<Expr>,
-                    Vec<(Expr, Option<String>)>,
+                    Vec<(Expr, _)>,
                 ) = group_expr
                     .into_iter()
                     .enumerate()
@@ -166,10 +164,7 @@ impl OptimizerRule for SingleDistinctToGroupBy {
                             let (qualifier, field) = schema.qualified_field(i);
                             (
                                 group_expr.alias(alias_str.clone()),
-                                (
-                                    col(alias_str),
-                                    Some(qualified_name(qualifier, field.name())),
-                                ),
+                                (col(alias_str), Some((qualifier, field.name()))),
                             )
                         }
                     })
@@ -253,19 +248,17 @@ impl OptimizerRule for SingleDistinctToGroupBy {
                 // - aggr expr
                 let alias_expr: Vec<_> = out_group_expr_with_alias
                     .into_iter()
-                    .map(|(group_expr, original_field)| {
-                        if let Some(name) = original_field {
-                            group_expr.alias(name)
-                        } else {
-                            group_expr
+                    .map(|(group_expr, original_name)| match original_name {
+                        Some((qualifier, name)) => {
+                            group_expr.alias_qualified(qualifier.cloned(), name)
                         }
+                        None => group_expr,
                     })
                     .chain(outer_aggr_exprs.iter().cloned().enumerate().map(
                         |(idx, expr)| {
                             let idx = idx + group_size;
                             let (qualifier, field) = schema.qualified_field(idx);
-                            let name = qualified_name(qualifier, field.name());
-                            expr.alias(name)
+                            expr.alias_qualified(qualifier.cloned(), field.name())
                         },
                     ))
                     .collect();

diff --git a/datafusion/sqllogictest/test_files/select.slt b/datafusion/sqllogictest/test_files/select.slt
@@ -1756,3 +1756,7 @@ SELECT "test.a" FROM (SELECT a AS "test.a" FROM test)
 
 statement ok
 DROP TABLE test;
+
+# Can't reference an unqualified column by a qualified name
+query error DataFusion error: Schema error: No field named t1\.v1\. Valid fields are "t1\.v1"\.
+SELECT t1.v1 FROM (SELECT 1 AS "t1.v1");