Function query_to_set_expr

prqlc/prqlc/src/sql/gen_query.rs:690–732

(query: sql_ast::Query, context: &mut Context)

}

fn query_to_set_expr(query: sql_ast::Query, context: &mut Context) -> Box<SetExpr> {
    let is_simple = query.with.is_none()
        && query.order_by.is_none()
        && query.limit_clause.is_none()
        && query.fetch.is_none()
        && query.locks.is_empty();

    if is_simple {
        return query.body;
    }

    // Query is not simple, so we need to wrap it.
    //
    // Some engines (like SQLite) do not support subqueries between simple parentheses, so we keep
    // the general `SELECT * FROM (query)` by default.
    //
    // Some engines (like Postgres) may need the subquery directly as-is or between parentheses
    // to properly match columns for syntaxes like `UNION`, `EXCEPT`, and `INTERSECT`.
    // Incidentally, the parenthesis syntax `(query)` allows for complex queries.
    let set_expr = if context.dialect.prefers_subquery_parentheses_shorthand() {
        SetExpr::Query(query.into())
    } else {
        SetExpr::Select(Box::new(Select {
            projection: vec![SelectItem::Wildcard(
                sql_ast::WildcardAdditionalOptions::default(),
            )],
            from: vec![TableWithJoins {
                relation: TableFactor::Derived {
                    lateral: false,
                    subquery: Box::new(query),
                    alias: Some(simple_table_alias(sql_ast::Ident::new(
                        context.anchor.table_name.gen(),
                    ))),
                    sample: None,
                },
                joins: vec![],
            }],
            ..default_select()
        }))
    };

    Box::new(set_expr)
}

fn count_tables(transforms: &[Transform]) -> usize {
    let mut count = 0;