SQLAlchemy的UNION作为CTE缺少外部括号

Question

I try to use SQLAlchemy to generate a query like

WITH
_cte_a AS (SELECT x FROM some_table),
_cte_b AS (SELECT x FROM next_table),
_cte_c AS (
    SELECT x FROM _cte_a
    UNION ALL
    SELECT x FROM _cte_b)
SELECT *
FROM _cte_c;

(I know that this very query does not really make sense in terms of the common table expressions, but just let it be my desired output.)

Using SQLAlchemy's selectables , my code looks like this:

import sqlalchemy as sa

cte_a = sa.select(
    [sa.column('x')]
).select_from(some_table).cte('_cte_a')

cte_b = sa.select(
    [sa.column('x')]
).select_from(next_table).cte('_cte_b')

cte_c = sa.union_all(cte_a, cte_b).cte('_cte_c')

# Query with session context; unavailable before.
query = session.query('*').select_from(cte_c)

But the generated output is:

WITH
_cte_a AS (SELECT x FROM some_table),
_cte_b AS (SELECT x FROM some_table),
_cte_c AS
    SELECT x FROM _cte_a
    UNION ALL
    SELECT x FROM _cte_b
SELECT *
FROM _cte_c;

Note the missing parentheses around the CTE definition in the query result. For some reason, SQLAlchemy refuses to create them when building the query part for a CTE that contains a CompoundSelect object as its element.

I found a solution to a similar problem that proposes using session.query(...).subquery() and then combining their respective results using sa.union_all(...) , but as I do not have the session available, I cannot follow this approach.

I've tried like all possibilities (using alias() , enforcing parens using order_by() , and many more) but nothing yields the desired result. I even replaced SQLCompiler.visit_compound_select method to enforce using parentheses (it is called recursively and does not place parens under certain circumstances).

Nothing helped, and I'm already biting my table. Maybe I am missing something very basic? I would very much appreciate it if someone of you could push me into the correct direction.

Edit: Also tried select() on the inner CTEs before UNION ing them, still no success. Even when I nest the UNION deeper into selects, the result remains the same.

Edit (2): This is really weird. Breaking down my (rather complex) original code to a MWE, the parentheses have switched. Now, they are missing for regular CTEs, but are available for the UNION'ed one:

meta = sa.MetaData()
t_some = sa.Table('some_table', meta, sa.Column('x', sa.Integer))
t_next = sa.Table('next_table', meta, sa.Column('x', sa.Integer))

cte_a = sa.select([
    t_some.c.x.label('x')
]).select_from(
    t_some
).cte('_cte_a')

cte_b = sa.select([
    t_next.c.x.label('x')
]).select_from(
    t_next
).cte('_cte_b')

cte_c = sa.select([
    sa.column('x')
]).select_from(
    sa.union_all(
        cte_a, cte_b
    )
).cte('_cte_c')

query = session.query(
    sa.select([sa.column('x')]).select_from(cte_c)
).order_by(
    sa.column('x').asc()
)
print(query)

... yields the query:

WITH _cte_a AS 
SELECT some_table.x AS x 
FROM some_table, 
_cte_b AS 
SELECT next_table.x AS x 
FROM next_table, 
_cte_c AS 
(SELECT x 
FROM (_cte_a UNION ALL _cte_b))
 SELECT x AS x 
FROM (SELECT x 
FROM _cte_c) ORDER BY x ASC

Note that now the parentheses are missing for _cte_a and _cte_b .

I really feel like I am missing something very basic here...

Answer 1

There are some unnecessarily verbose constructs and the union_all() call is wrong, which seems to throw the compiler off. Instead of CTE instances pass it Select instances. You'd also usually pass Session.query() entities to select, not queries:

In [57]: cte_a = select([t_some.c.x]).cte('cte_a')

In [58]: cte_b = select([t_next.c.x]).cte('cte_b')

In [59]: cte_c = select([cte_a.c.x]).union_all(select([cte_b.c.x])).cte('cte_c')

In [60]: session.query(cte_c.c.x).order_by(cte_c.c.x)
Out[60]: <sqlalchemy.orm.query.Query at 0x7f7a5998e400>

In [61]: print(_)
WITH cte_a AS 
(SELECT some_table.x AS x 
FROM some_table), 
cte_b AS 
(SELECT next_table.x AS x 
FROM next_table), 
cte_c AS 
(SELECT cte_a.x AS x 
FROM cte_a UNION ALL SELECT cte_b.x AS x 
FROM cte_b)
 SELECT cte_c.x AS cte_c_x 
FROM cte_c ORDER BY cte_c.x