datafusion icon indicating copy to clipboard operation
datafusion copied to clipboard

Using Union's input schema when recompute schema

Open yyy1000 opened this issue 1 year ago • 2 comments

Which issue does this PR close?

Closes #.

Rationale for this change

What changes are included in this PR?

Are these changes tested?

Are there any user-facing changes?

yyy1000 avatar May 14 '24 02:05 yyy1000

This is an example. The sql is

SELECT A.col_int32 FROM test AS A \
        INNER JOIN ( \
          SELECT col_int32 FROM test WHERE 1 = 0 \
        ) AS B ON A.col_int32 = B.col_int32 \
        UNION ALL \
        SELECT test.col_int32 FROM test WHERE 1 = 1 \
        UNION ALL \
        SELECT test.col_int32 FROM test WHERE 0 = 0 \
        UNION ALL \
        SELECT test.col_int32 FROM test WHERE test.col_int32 < 0 \
        UNION ALL \
        SELECT test.col_int32 FROM test WHERE 1 = 0
+----------------------------------------------------------------------------+----------------------------------------------------------------------------+
| plan_type                                                                  | plan                                                                       |
+----------------------------------------------------------------------------+----------------------------------------------------------------------------+
| initial_logical_plan                                                       | Union                                                                      |
|                                                                            |   Union                                                                    |
|                                                                            |     Union                                                                  |
|                                                                            |       Union                                                                |
|                                                                            |         Projection: a.col_int32                                            |
|                                                                            |           Inner Join:  Filter: a.col_int32 = b.col_int32                   |
|                                                                            |             SubqueryAlias: a                                               |
|                                                                            |               TableScan: test                                              |
|                                                                            |             SubqueryAlias: b                                               |
|                                                                            |               Projection: test.col_int32                                   |
|                                                                            |                 Filter: Int64(1) = Int64(0)                                |
|                                                                            |                   TableScan: test                                          |
|                                                                            |         Projection: test.col_int32                                         |
|                                                                            |           Filter: Int64(1) = Int64(1)                                      |
|                                                                            |             TableScan: test                                                |
|                                                                            |       Projection: test.col_int32                                           |
|                                                                            |         Filter: Int64(0) = Int64(0)                                        |
|                                                                            |           TableScan: test                                                  |
|                                                                            |     Projection: test.col_int32                                             |
|                                                                            |       Filter: test.col_int32 < Int64(0)                                    |
|                                                                            |         TableScan: test                                                    |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Int64(1) = Int64(0)                                            |
|                                                                            |       TableScan: test                                                      |
| logical_plan after apply_function_rewrites                                 | SAME TEXT AS ABOVE                                                         |
| logical_plan after inline_table_scan                                       | SAME TEXT AS ABOVE                                                         |
| logical_plan after type_coercion                                           | Union                                                                      |
|                                                                            |   Union                                                                    |
|                                                                            |     Union                                                                  |
|                                                                            |       Union                                                                |
|                                                                            |         Projection: a.col_int32                                            |
|                                                                            |           Inner Join:  Filter: a.col_int32 = b.col_int32                   |
|                                                                            |             SubqueryAlias: a                                               |
|                                                                            |               TableScan: test                                              |
|                                                                            |             SubqueryAlias: b                                               |
|                                                                            |               Projection: test.col_int32                                   |
|                                                                            |                 Filter: Int64(1) = Int64(0)                                |
|                                                                            |                   TableScan: test                                          |
|                                                                            |         Projection: test.col_int32                                         |
|                                                                            |           Filter: Int64(1) = Int64(1)                                      |
|                                                                            |             TableScan: test                                                |
|                                                                            |       Projection: test.col_int32                                           |
|                                                                            |         Filter: Int64(0) = Int64(0)                                        |
|                                                                            |           TableScan: test                                                  |
|                                                                            |     Projection: test.col_int32                                             |
|                                                                            |       Filter: CAST(test.col_int32 AS Int64) < Int64(0)                     |
|                                                                            |         TableScan: test                                                    |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Int64(1) = Int64(0)                                            |
|                                                                            |       TableScan: test                                                      |
| logical_plan after count_wildcard_rule                                     | SAME TEXT AS ABOVE                                                         |
| analyzed_logical_plan                                                      | SAME TEXT AS ABOVE                                                         |
| logical_plan after eliminate_nested_union                                  | Union                                                                      |
|                                                                            |   Projection: a.col_int32                                                  |
|                                                                            |     Inner Join:  Filter: a.col_int32 = b.col_int32                         |
|                                                                            |       SubqueryAlias: a                                                     |
|                                                                            |         TableScan: test                                                    |
|                                                                            |       SubqueryAlias: b                                                     |
|                                                                            |         Projection: test.col_int32                                         |
|                                                                            |           Filter: Int64(1) = Int64(0)                                      |
|                                                                            |             TableScan: test                                                |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Int64(1) = Int64(1)                                            |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Int64(0) = Int64(0)                                            |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: CAST(test.col_int32 AS Int64) < Int64(0)                       |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Int64(1) = Int64(0)                                            |
|                                                                            |       TableScan: test                                                      |
| logical_plan after simplify_expressions                                    | Union                                                                      |
|                                                                            |   Projection: a.col_int32                                                  |
|                                                                            |     Inner Join:  Filter: a.col_int32 = b.col_int32                         |
|                                                                            |       SubqueryAlias: a                                                     |
|                                                                            |         TableScan: test                                                    |
|                                                                            |       SubqueryAlias: b                                                     |
|                                                                            |         Projection: test.col_int32                                         |
|                                                                            |           Filter: Boolean(false)                                           |
|                                                                            |             TableScan: test                                                |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(true)                                                  |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(true)                                                  |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: CAST(test.col_int32 AS Int64) < Int64(0)                       |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(false)                                                 |
|                                                                            |       TableScan: test                                                      |
| logical_plan after unwrap_cast_in_comparison                               | Union                                                                      |
|                                                                            |   Projection: a.col_int32                                                  |
|                                                                            |     Inner Join:  Filter: a.col_int32 = b.col_int32                         |
|                                                                            |       SubqueryAlias: a                                                     |
|                                                                            |         TableScan: test                                                    |
|                                                                            |       SubqueryAlias: b                                                     |
|                                                                            |         Projection: test.col_int32                                         |
|                                                                            |           Filter: Boolean(false)                                           |
|                                                                            |             TableScan: test                                                |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(true)                                                  |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(true)                                                  |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: test.col_int32 < Int32(0)                                      |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(false)                                                 |
|                                                                            |       TableScan: test                                                      |
| logical_plan after replace_distinct_aggregate                              | SAME TEXT AS ABOVE                                                         |
| logical_plan after eliminate_join                                          | SAME TEXT AS ABOVE                                                         |
| logical_plan after decorrelate_predicate_subquery                          | SAME TEXT AS ABOVE                                                         |
| logical_plan after scalar_subquery_to_join                                 | SAME TEXT AS ABOVE                                                         |
| logical_plan after extract_equijoin_predicate                              | Union                                                                      |
|                                                                            |   Projection: a.col_int32                                                  |
|                                                                            |     Inner Join: a.col_int32 = b.col_int32                                  |
|                                                                            |       SubqueryAlias: a                                                     |
|                                                                            |         TableScan: test                                                    |
|                                                                            |       SubqueryAlias: b                                                     |
|                                                                            |         Projection: test.col_int32                                         |
|                                                                            |           Filter: Boolean(false)                                           |
|                                                                            |             TableScan: test                                                |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(true)                                                  |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(true)                                                  |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: test.col_int32 < Int32(0)                                      |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: Boolean(false)                                                 |
|                                                                            |       TableScan: test                                                      |
| logical_plan after simplify_expressions                                    | SAME TEXT AS ABOVE                                                         |
| logical_plan after rewrite_disjunctive_predicate                           | SAME TEXT AS ABOVE                                                         |
| logical_plan after eliminate_duplicated_expr                               | SAME TEXT AS ABOVE                                                         |
| logical_plan after eliminate_filter                                        | Union                                                                      |
|                                                                            |   Projection: a.col_int32                                                  |
|                                                                            |     Inner Join: a.col_int32 = b.col_int32                                  |
|                                                                            |       SubqueryAlias: a                                                     |
|                                                                            |         TableScan: test                                                    |
|                                                                            |       SubqueryAlias: b                                                     |
|                                                                            |         Projection: test.col_int32                                         |
|                                                                            |           EmptyRelation                                                    |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     TableScan: test                                                        |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     TableScan: test                                                        |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: test.col_int32 < Int32(0)                                      |
|                                                                            |       TableScan: test                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     EmptyRelation                                                          |
| logical_plan after eliminate_cross_join                                    | SAME TEXT AS ABOVE                                                         |
| logical_plan after common_sub_expression_eliminate                         | SAME TEXT AS ABOVE                                                         |
| logical_plan after eliminate_limit                                         | SAME TEXT AS ABOVE                                                         |
| logical_plan after propagate_empty_relation                                | Union                                                                      |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     TableScan: test                                                        |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     TableScan: test                                                        |
|                                                                            |   Projection: test.col_int32                                               |
|                                                                            |     Filter: test.col_int32 < Int32(0)                                      |
|                                                                            |       TableScan: test                                                      |
| logical_plan after eliminate_one_union                                     | SAME TEXT AS ABOVE                                                         |
| logical_plan after filter_null_join_keys                                   | SAME TEXT AS ABOVE                                                         |
| logical_plan after eliminate_outer_join                                    | SAME TEXT AS ABOVE                                                         |
| logical_plan after push_down_limit                                         | SAME TEXT AS ABOVE                                                         |
| logical_plan after push_down_filter                                        | SAME TEXT AS ABOVE                                                         |
| logical_plan after single_distinct_aggregation_to_group_by                 | SAME TEXT AS ABOVE                                                         |
| logical_plan after simplify_expressions                                    | SAME TEXT AS ABOVE                                                         |
| logical_plan after unwrap_cast_in_comparison                               | SAME TEXT AS ABOVE                                                         |
| logical_plan after Optimizer rule 'common_sub_expression_eliminate' failed | Schema error: No field named a.col_int32. Valid fields are test.col_int32. |
+----------------------------------------------------------------------------+----------------------------------------------------------------------------+

yyy1000 avatar May 14 '24 04:05 yyy1000

Marking as draft as I think this PR is no longer waiting on feedback.

alamb avatar May 15 '24 19:05 alamb

Thank you for your contribution. Unfortunately, this pull request is stale because it has been open 60 days with no activity. Please remove the stale label or comment or this will be closed in 7 days.

github-actions[bot] avatar Jul 15 '24 01:07 github-actions[bot]