add new changes

zhuqi-lucas · zhuqi-lucas · commit 4c1bfe292e4c · 2025-07-29T17:15:11.000+08:00
diff --git a/datafusion/common/src/column.rs b/datafusion/common/src/column.rs
@@ -30,7 +30,7 @@ use std::str::FromStr;
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Column {
     /// relation/table reference.
-    pub relation: Option<TableReference>,
+    pub relation: Box<Option<TableReference>>,
     /// field/column name.
     pub name: String,
     /// Original source code location, if known
@@ -58,7 +58,7 @@ impl Column {
         name: impl Into<String>,
     ) -> Self {
         Self {
-            relation: relation.map(|r| r.into()),
+            relation: Box::new(relation.map(|r| r.into())),
             name: name.into(),
             spans: Spans::new(),
         }
@@ -67,7 +67,7 @@ impl Column {
     /// Convenience method for when there is no qualifier
     pub fn new_unqualified(name: impl Into<String>) -> Self {
         Self {
-            relation: None,
+            relation: Box::new(None),
             name: name.into(),
             spans: Spans::new(),
         }
@@ -78,7 +78,7 @@ impl Column {
     /// Alias for `Column::new_unqualified`
     pub fn from_name(name: impl Into<String>) -> Self {
         Self {
-            relation: None,
+            relation: Box::new(None),
             name: name.into(),
             spans: Spans::new(),
         }
@@ -116,6 +116,8 @@ impl Column {
             // identifiers will be treated as an unqualified column name
             _ => return None,
         };
+
+        let relation = Box::new(relation);
         Some(Self {
             relation,
             name,
@@ -132,7 +134,7 @@ impl Column {
         let flat_name = flat_name.into();
         Self::from_idents(parse_identifiers_normalized(&flat_name, false)).unwrap_or_else(
             || Self {
-                relation: None,
+                relation: Box::new(None),
                 name: flat_name,
                 spans: Spans::new(),
             },
@@ -144,7 +146,7 @@ impl Column {
         let flat_name = flat_name.into();
         Self::from_idents(parse_identifiers_normalized(&flat_name, true)).unwrap_or_else(
             || Self {
-                relation: None,
+                relation: Box::new(None),
                 name: flat_name,
                 spans: Spans::new(),
             },
@@ -160,15 +162,15 @@ impl Column {
 
     /// Serialize column into a flat name string
     pub fn flat_name(&self) -> String {
-        match &self.relation {
+        match &*self.relation {
             Some(r) => format!("{}.{}", r, self.name),
             None => self.name.clone(),
         }
     }
 
     /// Serialize column into a quoted flat name string
     pub fn quoted_flat_name(&self) -> String {
-        match &self.relation {
+        match &*self.relation {
             Some(r) => {
                 format!(
                     "{}.{}",
@@ -316,7 +318,7 @@ impl Column {
     /// Qualifies the column with the given table reference.
     pub fn with_relation(&self, relation: TableReference) -> Self {
         Self {
-            relation: Some(relation),
+            relation: Box::new(Some(relation)),
             ..self.clone()
         }
     }
diff --git a/datafusion/common/src/dfschema.rs b/datafusion/common/src/dfschema.rs
@@ -379,7 +379,7 @@ impl DFSchema {
     /// See [Self::index_of_column] for a version that returns an error if the
     /// column is not found
     pub fn maybe_index_of_column(&self, col: &Column) -> Option<usize> {
-        self.index_of_column_by_name(col.relation.as_ref(), &col.name)
+        self.index_of_column_by_name(col.relation.as_ref().as_ref(), &col.name)
     }
 
     /// Find the index of the column with the given qualifier and name,
@@ -388,13 +388,14 @@ impl DFSchema {
     /// See [Self::maybe_index_of_column] for a version that returns `None` if
     /// the column is not found
     pub fn index_of_column(&self, col: &Column) -> Result<usize> {
-        self.maybe_index_of_column(col)
-            .ok_or_else(|| field_not_found(col.relation.clone(), &col.name, self))
+        self.maybe_index_of_column(col).ok_or_else(|| {
+            field_not_found(col.relation.as_ref().clone(), &col.name, self)
+        })
     }
 
     /// Check if the column is in the current schema
     pub fn is_column_from_schema(&self, col: &Column) -> bool {
-        self.index_of_column_by_name(col.relation.as_ref(), &col.name)
+        self.index_of_column_by_name(col.relation.as_ref().as_ref(), &col.name)
             .is_some()
     }
 
@@ -539,7 +540,7 @@ impl DFSchema {
         &self,
         column: &Column,
     ) -> Result<(Option<&TableReference>, &Field)> {
-        self.qualified_field_with_name(column.relation.as_ref(), &column.name)
+        self.qualified_field_with_name(column.relation.as_ref().as_ref(), &column.name)
     }
 
     /// Find if the field exists with the given name
@@ -559,7 +560,7 @@ impl DFSchema {
 
     /// Find if the field exists with the given qualified column
     pub fn has_column(&self, column: &Column) -> bool {
-        match &column.relation {
+        match &*column.relation {
             Some(r) => self.has_column_with_qualified_name(r, &column.name),
             None => self.has_column_with_unqualified_name(&column.name),
         }
@@ -1029,7 +1030,7 @@ impl<P: AsRef<DFSchema> + std::fmt::Debug> ExprSchema for P {
 
 impl ExprSchema for DFSchema {
     fn field_from_column(&self, col: &Column) -> Result<&Field> {
-        match &col.relation {
+        match &*col.relation {
             Some(r) => self.field_with_qualified_name(r, &col.name),
             None => self.field_with_unqualified_name(&col.name),
         }
diff --git a/datafusion/core/src/dataframe/mod.rs b/datafusion/core/src/dataframe/mod.rs
@@ -2296,7 +2296,7 @@ impl DataFrame {
                                 func: coalesce(),
                                 args: vec![col(field.name()), lit(fill_value)],
                             })),
-                            relation: None,
+                            relation: Box::new(None),
                             name: field.name().to_string(),
                             metadata: None,
                         }),
diff --git a/datafusion/core/tests/dataframe/mod.rs b/datafusion/core/tests/dataframe/mod.rs
@@ -5668,7 +5668,7 @@ async fn test_alias() -> Result<()> {
         .alias("table_alias")?;
     // All ouput column qualifiers are changed to "table_alias"
     df.schema().columns().iter().for_each(|c| {
-        assert_eq!(c.relation, Some("table_alias".into()));
+        assert_eq!(*c.relation, Some("table_alias".into()));
     });
 
     let plan = df
diff --git a/datafusion/core/tests/execution/logical_plan.rs b/datafusion/core/tests/execution/logical_plan.rs
@@ -53,7 +53,7 @@ async fn count_only_nulls() -> Result<()> {
         ],
     }));
     let input_col_ref = Expr::Column(Column {
-        relation: None,
+        relation: Box::new(None),
         name: "col".to_string(),
         spans: Spans::new(),
     });
diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rs
@@ -623,7 +623,7 @@ impl Unnest {
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Alias {
     pub expr: Box<Expr>,
-    pub relation: Option<TableReference>,
+    pub relation: Box<Option<TableReference>>,
     pub name: String,
     pub metadata: Option<FieldMetadata>,
 }
@@ -659,7 +659,7 @@ impl Alias {
     ) -> Self {
         Self {
             expr: Box::new(expr),
-            relation: relation.map(|r| r.into()),
+            relation: Box::new(relation.map(|r| r.into())),
             name: name.into(),
             metadata: None,
         }
@@ -1423,8 +1423,10 @@ impl Expr {
                 relation,
                 name,
                 spans: _,
-            }) => (relation.clone(), name.clone()),
-            Expr::Alias(Alias { relation, name, .. }) => (relation.clone(), name.clone()),
+            }) => (relation.as_ref().clone(), name.clone()),
+            Expr::Alias(Alias { relation, name, .. }) => {
+                (*relation.clone(), name.clone())
+            }
             _ => (None, self.schema_name().to_string()),
         }
     }
@@ -2673,12 +2675,10 @@ impl Display for SchemaDisplay<'_> {
                 }
             }
             // Expr is not shown since it is aliased
-            Expr::Alias(Alias {
-                name,
-                relation: Some(relation),
-                ..
-            }) => write!(f, "{relation}.{name}"),
-            Expr::Alias(Alias { name, .. }) => write!(f, "{name}"),
+            Expr::Alias(Alias { name, relation, .. }) => match relation.as_ref() {
+                Some(rel) => write!(f, "{rel}.{name}"),
+                None => write!(f, "{name}"),
+            },
             Expr::Between(Between {
                 expr,
                 negated,
@@ -3839,7 +3839,7 @@ mod test {
         // If this test fails when you change `Expr`, please try
         // `Box`ing the fields to make `Expr` smaller
         // See https://github.com/apache/datafusion/issues/16199 for details
-        assert_eq!(size_of::<Expr>(), 128);
+        assert_eq!(size_of::<Expr>(), 96);
         assert_eq!(size_of::<ScalarValue>(), 64);
         assert_eq!(size_of::<DataType>(), 24); // 3 ptrs
         assert_eq!(size_of::<Vec<Expr>>(), 24);
diff --git a/datafusion/expr/src/logical_plan/builder.rs b/datafusion/expr/src/logical_plan/builder.rs
@@ -1021,7 +1021,7 @@ impl LogicalPlanBuilder {
                     let l = l.into();
                     let r = r.into();
 
-                    match (&l.relation, &r.relation) {
+                    match (&*l.relation, &*r.relation) {
                         (Some(lr), Some(rr)) => {
                             let l_is_left =
                                 self.plan.schema().field_with_qualified_name(lr, &l.name);
@@ -2388,7 +2388,7 @@ mod tests {
                         name,
                         spans: _,
                     } = *field;
-                    let Some(TableReference::Bare { table }) = relation else {
+                    let Some(TableReference::Bare { table }) = *relation else {
                         return plan_err!(
                             "wrong relation: {relation:?}, expected table name"
                         );
diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rs
@@ -4163,7 +4163,7 @@ impl Unnest {
                         Ok(transformed_columns
                             .iter()
                             .map(|(col, field)| {
-                                (col.relation.to_owned(), field.to_owned())
+                                (col.relation.as_ref().to_owned(), field.to_owned())
                             })
                             .collect())
                     }
diff --git a/datafusion/expr/src/tree_node.rs b/datafusion/expr/src/tree_node.rs
@@ -136,7 +136,7 @@ impl TreeNode for Expr {
                 name,
                 metadata,
             }) => f(*expr)?.update_data(|e| {
-                e.alias_qualified_with_metadata(relation, name, metadata)
+                e.alias_qualified_with_metadata(*relation, name, metadata)
             }),
             Expr::InSubquery(InSubquery {
                 expr,
diff --git a/datafusion/optimizer/src/analyzer/resolve_grouping_function.rs b/datafusion/optimizer/src/analyzer/resolve_grouping_function.rs
@@ -105,7 +105,7 @@ fn replace_grouping_exprs(
                 )?;
                 projection_exprs.push(Expr::Alias(Alias::new(
                     grouping_expr,
-                    column.relation,
+                    *column.relation,
                     column.name,
                 )));
             }
diff --git a/datafusion/optimizer/src/optimize_projections/mod.rs b/datafusion/optimizer/src/optimize_projections/mod.rs
@@ -516,7 +516,7 @@ fn merge_consecutive_projections(proj: Projection) -> Result<Transformed<Project
                 metadata,
             }) => rewrite_expr(*expr, &prev_projection).map(|result| {
                 result.update_data(|expr| {
-                    Expr::Alias(Alias::new(expr, relation, name).with_metadata(metadata))
+                    Expr::Alias(Alias::new(expr, *relation, name).with_metadata(metadata))
                 })
             }),
             e => rewrite_expr(e, &prev_projection),
@@ -818,7 +818,8 @@ pub fn is_projection_unnecessary(
         |((field_relation, field_name), expr)| {
             // Check if the expression is a column and if it matches the field name
             if let Expr::Column(col) = expr {
-                col.relation.as_ref() == field_relation && col.name.eq(field_name.name())
+                col.relation.as_ref().as_ref() == field_relation
+                    && col.name.eq(field_name.name())
             } else {
                 false
             }
diff --git a/datafusion/sql/src/expr/mod.rs b/datafusion/sql/src/expr/mod.rs
@@ -176,7 +176,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
     /// Rewrite aliases which are not-complete (e.g. ones that only include only table qualifier in a schema.table qualified relation)
     fn rewrite_partial_qualifier(&self, expr: Expr, schema: &DFSchema) -> Expr {
         match expr {
-            Expr::Column(col) => match &col.relation {
+            Expr::Column(col) => match &*col.relation {
                 Some(q) => {
                     match schema.iter().find(|(qualifier, field)| match qualifier {
                         Some(field_q) => {
diff --git a/datafusion/sql/src/planner.rs b/datafusion/sql/src/planner.rs
@@ -470,14 +470,14 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         find_column_exprs(exprs)
             .iter()
             .try_for_each(|col| match col {
-                Expr::Column(col) => match &col.relation {
+                Expr::Column(col) => match &*col.relation {
                     Some(r) => schema.field_with_qualified_name(r, &col.name).map(|_| ()),
                     None => {
                         if !schema.fields_with_unqualified_name(&col.name).is_empty() {
                             Ok(())
                         } else {
                             Err(field_not_found(
-                                col.relation.clone(),
+                                col.relation.as_ref().clone(),
                                 col.name.as_str(),
                                 schema,
                             ))
@@ -498,7 +498,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                         else {
                             unreachable!()
                         };
-                        let mut diagnostic = if let Some(relation) = &col.relation {
+                        let mut diagnostic = if let Some(relation) = &*col.relation {
                             Diagnostic::new_error(
                                 format!(
                                     "column '{}' not found in '{}'",
diff --git a/datafusion/sql/src/unparser/expr.rs b/datafusion/sql/src/unparser/expr.rs
@@ -736,7 +736,7 @@ impl Unparser<'_> {
                 col.name.to_string()
             };
 
-        if let Some(table_ref) = &col.relation {
+        if let Some(table_ref) = &*col.relation {
             let mut id = if self.dialect.full_qualified_col() {
                 table_ref.to_vec()
             } else {
@@ -1829,7 +1829,7 @@ mod tests {
             ((col("a") + col("b")).gt(lit(4)), r#"((a + b) > 4)"#),
             (
                 Expr::Column(Column {
-                    relation: Some(TableReference::partial("a", "b")),
+                    relation: Box::new(Some(TableReference::partial("a", "b"))),
                     name: "c".to_string(),
                     spans: Spans::new(),
                 })
@@ -2187,7 +2187,9 @@ mod tests {
             (
                 Expr::Unnest(Unnest {
                     expr: Box::new(Expr::Column(Column {
-                        relation: Some(TableReference::partial("schema", "table")),
+                        relation: Box::new(Some(TableReference::partial(
+                            "schema", "table",
+                        ))),
                         name: "array_col".to_string(),
                         spans: Spans::new(),
                     })),
diff --git a/datafusion/sql/src/unparser/rewrite.rs b/datafusion/sql/src/unparser/rewrite.rs
@@ -88,7 +88,7 @@ fn rewrite_sort_expr_for_union(exprs: Vec<SortExpr>) -> Result<Vec<SortExpr>> {
         .map_elements(&mut |expr: Expr| {
             expr.transform_up(|expr| {
                 if let Expr::Column(mut col) = expr {
-                    col.relation = None;
+                    col.relation = Box::new(None);
                     Ok(Transformed::yes(Expr::Column(col)))
                 } else {
                     Ok(Transformed::no(expr))
@@ -356,7 +356,7 @@ pub(super) fn inject_column_aliases(
         .map(|(expr, col_alias)| {
             let relation = match &expr {
                 Expr::Column(col) => col.relation.clone(),
-                _ => None,
+                _ => Box::new(None),
             };
 
             Expr::Alias(Alias {

Original file line number	Diff line number	Diff line change
`@@ -4163,7 +4163,7 @@ impl Unnest {`
`4163`	`4163`	`Ok(transformed_columns`
`4164`	`4164`	`.iter()`
`4165`	`4165`	`.map(\|(col, field)\| {`
`4166`		`- (col.relation.to_owned(), field.to_owned())`
	`4166`	`+ (col.relation.as_ref().to_owned(), field.to_owned())`
`4167`	`4167`	`})`
`4168`	`4168`	`.collect())`
`4169`	`4169`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ fn replace_grouping_exprs(`
`105`	`105`	`)?;`
`106`	`106`	`projection_exprs.push(Expr::Alias(Alias::new(`
`107`	`107`	`grouping_expr,`
`108`		`- column.relation,`
	`108`	`+ *column.relation,`
`109`	`109`	`column.name,`
`110`	`110`	`)));`
`111`	`111`	`}`