fix: inherit field names from left projection in set expressions when missing

gruuya · gruuya · commit b20fa4050bfb · 2026-03-09T13:07:29.000+01:00
Otherwise they might end up having the same column names, which is prohibited.
This is only the case for literals, other expression types should have default unique names.
diff --git a/datafusion/sql/src/set_expr.rs b/datafusion/sql/src/set_expr.rs
@@ -17,10 +17,12 @@
 
 use crate::planner::{ContextProvider, PlannerContext, SqlToRel};
 use datafusion_common::{
-    DataFusionError, Diagnostic, Result, Span, not_impl_err, plan_err,
+    DFSchemaRef, DataFusionError, Diagnostic, Result, Span, not_impl_err, plan_err,
 };
 use datafusion_expr::{LogicalPlan, LogicalPlanBuilder};
-use sqlparser::ast::{SetExpr, SetOperator, SetQuantifier, Spanned};
+use sqlparser::ast::{
+    Expr as SQLExpr, Ident, SelectItem, SetExpr, SetOperator, SetQuantifier, Spanned,
+};
 
 impl<S: ContextProvider> SqlToRel<'_, S> {
     #[cfg_attr(feature = "recursive_protection", recursive::recursive)]
@@ -42,7 +44,27 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
                 let left_span = Span::try_from_sqlparser_span(left.span());
                 let right_span = Span::try_from_sqlparser_span(right.span());
                 let left_plan = self.set_expr_to_plan(*left, planner_context);
-                let right_plan = self.set_expr_to_plan(*right, planner_context);
+
+                // For non-*ByName operations, add missing aliases to right side using left schema's
+                // column names. This allows queries like
+                // `SELECT 1 c1, 0 c2, 0 c3 UNION ALL SELECT 2, 0, 0`
+                // where the right side has duplicate literal values.
+                // We only do this if the left side succeeded.
+                let right = if let Ok(plan) = &left_plan
+                    && matches!(
+                        set_quantifier,
+                        SetQuantifier::All
+                            | SetQuantifier::Distinct
+                            | SetQuantifier::None
+                    ) {
+                    alias_set_expr(*right, plan.schema())
+                } else {
+                    *right
+                };
+
+                let right_plan = self.set_expr_to_plan(right, planner_context);
+
+                // Handle errors from both sides, collecting them if both failed
                 let (left_plan, right_plan) = match (left_plan, right_plan) {
                     (Ok(left_plan), Ok(right_plan)) => (left_plan, right_plan),
                     (Err(left_err), Err(right_err)) => {
@@ -160,3 +182,75 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
         }
     }
 }
+
+// Adds aliases to SELECT items in a SetExpr using the provided schema.
+// This ensures that unnamed expressions on the right side of a UNION/INTERSECT/EXCEPT
+// get aliased with the column names from the left side, allowing queries like
+// `SELECT 1 AS a, 0 AS b, 0 AS c UNION ALL SELECT 2, 0, 0` to work correctly.
+fn alias_set_expr(set_expr: SetExpr, schema: &DFSchemaRef) -> SetExpr {
+    match set_expr {
+        SetExpr::Select(mut select) => {
+            alias_select_items(&mut select.projection, schema);
+            SetExpr::Select(select)
+        }
+        SetExpr::SetOperation {
+            op,
+            left,
+            right,
+            set_quantifier,
+        } => {
+            // For nested set operations, only alias the leftmost branch
+            // since that's what determines the output column names
+            SetExpr::SetOperation {
+                op,
+                left: Box::new(alias_set_expr(*left, schema)),
+                right,
+                set_quantifier,
+            }
+        }
+        SetExpr::Query(mut query) => {
+            // Handle parenthesized queries like (SELECT ... UNION ALL SELECT ...)
+            query.body = Box::new(alias_set_expr(*query.body, schema));
+            SetExpr::Query(query)
+        }
+        // For other cases (Values, etc.), return as-is
+        other => other,
+    }
+}
+
+// Adds aliases to literal value expressions where missing, based on the input schema, as these are
+// the ones that can cause duplicate name issues (e.g. `SELECT 0, 0` has two columns named `Int64(0)`).
+// Other expressions typically have unique names.
+fn alias_select_items(items: &mut [SelectItem], schema: &DFSchemaRef) {
+    let mut col_idx = 0;
+    for item in items.iter_mut() {
+        match item {
+            SelectItem::UnnamedExpr(expr) if is_literal_value(expr) => {
+                if let Some(field) = schema.fields().get(col_idx) {
+                    *item = SelectItem::ExprWithAlias {
+                        expr: expr.clone(),
+                        alias: Ident::new(field.name()),
+                    };
+                }
+                col_idx += 1;
+            }
+            SelectItem::UnnamedExpr(_) | SelectItem::ExprWithAlias { .. } => {
+                col_idx += 1;
+            }
+            SelectItem::Wildcard(_) | SelectItem::QualifiedWildcard(_, _) => {
+                // Wildcards expand to multiple columns - skip position tracking
+            }
+        }
+    }
+}
+
+/// Returns true if the expression is a literal value that could cause duplicate names.
+fn is_literal_value(expr: &SQLExpr) -> bool {
+    matches!(
+        expr,
+        SQLExpr::Value(_)
+            | SQLExpr::UnaryOp { .. }
+            | SQLExpr::TypedString { .. }
+            | SQLExpr::Interval(_)
+    )
+}
diff --git a/datafusion/sql/tests/sql_integration.rs b/datafusion/sql/tests/sql_integration.rs
@@ -2655,6 +2655,115 @@ fn union_all_by_name_same_column_names() {
     );
 }
 
+#[test]
+fn union_all_with_duplicate_literals() {
+    let sql = "SELECT 1 as one, 0 as two, 0 as three UNION ALL SELECT 2, 0, 0";
+    let plan = logical_plan(sql).unwrap();
+    assert_snapshot!(
+        plan,
+        @r"
+    Union
+      Projection: Int64(1) AS one, Int64(0) AS two, Int64(0) AS three
+        EmptyRelation: rows=1
+      Projection: Int64(2) AS one, Int64(0) AS two, Int64(0) AS three
+        EmptyRelation: rows=1
+    "
+    );
+}
+
+#[test]
+fn union_with_duplicate_literals() {
+    let sql = "SELECT 1 as a, 2 as b UNION SELECT 3, 3";
+    let plan = logical_plan(sql).unwrap();
+    assert_snapshot!(
+        plan,
+        @r"
+    Distinct:
+      Union
+        Projection: Int64(1) AS a, Int64(2) AS b
+          EmptyRelation: rows=1
+        Projection: Int64(3) AS a, Int64(3) AS b
+          EmptyRelation: rows=1
+    "
+    );
+}
+
+#[test]
+fn intersect_with_duplicate_literals() {
+    let sql = "SELECT 1 as a, 0 as b, 0 as c INTERSECT SELECT 1, 0, 0";
+    let plan = logical_plan(sql).unwrap();
+    assert_snapshot!(
+        plan,
+        @r"
+    LeftSemi Join: left.a = right.a, left.b = right.b, left.c = right.c
+      Distinct:
+        SubqueryAlias: left
+          Projection: Int64(1) AS a, Int64(0) AS b, Int64(0) AS c
+            EmptyRelation: rows=1
+      SubqueryAlias: right
+        Projection: Int64(1) AS a, Int64(0) AS b, Int64(0) AS c
+          EmptyRelation: rows=1
+    "
+    );
+}
+
+#[test]
+fn except_with_duplicate_literals() {
+    let sql = "SELECT 1 as a, 0 as b, 0 as c EXCEPT SELECT 2, 0, 0";
+    let plan = logical_plan(sql).unwrap();
+    assert_snapshot!(
+        plan,
+        @r"
+    LeftAnti Join: left.a = right.a, left.b = right.b, left.c = right.c
+      Distinct:
+        SubqueryAlias: left
+          Projection: Int64(1) AS a, Int64(0) AS b, Int64(0) AS c
+            EmptyRelation: rows=1
+      SubqueryAlias: right
+        Projection: Int64(2) AS a, Int64(0) AS b, Int64(0) AS c
+          EmptyRelation: rows=1
+    "
+    );
+}
+
+#[test]
+fn nested_union_with_duplicate_literals() {
+    let sql = "SELECT 'a' as x, 1 as y UNION ALL SELECT 'b', 1 UNION ALL SELECT 'c', 1";
+    let plan = logical_plan(sql).unwrap();
+    assert_snapshot!(
+        plan,
+        @r#"
+    Union
+      Union
+        Projection: Utf8("a") AS x, Int64(1) AS y
+          EmptyRelation: rows=1
+        Projection: Utf8("b") AS x, Int64(1) AS y
+          EmptyRelation: rows=1
+      Projection: Utf8("c") AS x, Int64(1) AS y
+        EmptyRelation: rows=1
+    "#
+    );
+}
+
+#[test]
+fn right_nested_union_with_duplicate_literals() {
+    let sql = "SELECT 1 as a, 0 as b UNION ALL (SELECT 2, 0 UNION ALL SELECT 3, 0)";
+    let plan = logical_plan(sql).unwrap();
+    assert_snapshot!(
+        plan,
+        @r"
+    Union
+      Projection: Int64(1) AS a, Int64(0) AS b
+        EmptyRelation: rows=1
+      Union
+        Projection: Int64(2) AS a, Int64(0) AS b
+          EmptyRelation: rows=1
+        Projection: Int64(3) AS a, Int64(0) AS b
+          EmptyRelation: rows=1
+    "
+    );
+}
+
 #[test]
 fn empty_over() {
     let sql = "SELECT order_id, MAX(order_id) OVER () from orders";
diff --git a/datafusion/sqllogictest/test_files/union.slt b/datafusion/sqllogictest/test_files/union.slt
@@ -976,3 +976,38 @@ query TITT
               END
 ----
 ns3 4 t3 m
+
+# Test UNION ALL with duplicate literal values on the right side
+# The right side has duplicate 0 literals which should inherit column names from the left
+query III rowsort
+SELECT 1 as a, 0 as b, 0 as c
+UNION ALL
+SELECT 2, 0, 0
+----
+1 0 0
+2 0 0
+
+# Test nested UNION ALL with duplicate literals
+query II rowsort
+SELECT 1 as a, 0 as b
+UNION ALL
+SELECT 2, 0
+UNION ALL
+SELECT 3, 0
+----
+1 0
+2 0
+3 0
+
+# Test mixed set operations with nested EXCEPT and INTERSECT
+# Only the first SELECT has named columns, the rest inherit the schema
+query II rowsort
+SELECT 1 as a, 0 as b
+UNION ALL
+(SELECT 2, 0 EXCEPT SELECT 3, 0)
+UNION ALL
+(SELECT 4, 0 INTERSECT SELECT 4, 0)
+----
+1 0
+2 0
+4 0
