Function translate_relation_expr

prqlc/prqlc/src/sql/gen_query.rs:349–398

(relation_expr: RelationExpr, ctx: &mut Context)

}

fn translate_relation_expr(relation_expr: RelationExpr, ctx: &mut Context) -> Result<TableFactor> {
    let alias = Some(&relation_expr.riid)
        .and_then(|riid| ctx.anchor.relation_instances.get(riid))
        .and_then(|ri| ri.table_ref.name.clone());

    Ok(match relation_expr.kind {
        RelationExprKind::Ref(tid) => {
            let decl = ctx.anchor.lookup_table_decl(&tid).unwrap();

            // prepare names
            let table_name = decl.name.clone().unwrap();

            let name = sql_ast::ObjectName(
                translate_ident(Some(table_name.clone()), None, ctx)
                    .into_iter()
                    .map(sqlparser::ast::ObjectNamePart::Identifier)
                    .collect(),
            );

            TableFactor::Table {
                name,
                alias: if Some(table_name.name) == alias {
                    None
                } else {
                    translate_table_alias(alias, ctx)
                },
                args: None,
                with_hints: vec![],
                with_ordinality: false,
                version: None,
                partitions: vec![],
                json_path: None,
                sample: None,
                index_hints: vec![],
            }
        }
        RelationExprKind::SubQuery(query) => {
            let query = translate_relation(query, ctx)?;

            let alias = translate_table_alias(alias, ctx);

            TableFactor::Derived {
                lateral: false,
                subquery: Box::new(query),
                alias,
                sample: None,
            }
        }
    })
}

fn translate_table_alias(alias: Option<String>, ctx: &mut Context) -> Option<TableAlias> {
    alias