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

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.

Author: gruuya

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(_)
+    )
+}

datafusion/sql/tests/sql_integration.rs

@@ -2655,6 +2655,123 @@ fn union_all_by_name_same_column_names() {
     );
 }
 
+#[test]
+fn union_all_with_duplicate_literals() {
+    // Test that UNION ALL works with duplicate literal values in the right side
+    // The right side's expressions should inherit aliases from the left side's schema
+    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() {
+    // Test that UNION DISTINCT also works 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() {
+    // Test that INTERSECT works 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() {
+    // Test that EXCEPT works 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() {
+    // Test that nested UNIONs work correctly with duplicate literals (left-associative)
+    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() {
+    // Test that right-nested UNIONs work correctly with duplicate literals
+    // Here the right side is a parenthesized set operation
+    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";

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