Function translate_expr

prqlc/prqlc/src/sql/gen_expr.rs:24–141

(expr: rq::Expr, ctx: &mut Context)

use crate::{Error, Result, Span, WithErrorInfo};

pub(super) fn translate_expr(expr: rq::Expr, ctx: &mut Context) -> Result<ExprOrSource> {
    Ok(match expr.kind {
        rq::ExprKind::ColumnRef(cid) => translate_cid(cid, ctx)?,

        // Fairly hacky — convert everything to a string, then concat it,
        // then convert to sql_ast::Expr. We can't use the `Item::sql_ast::Expr` code above
        // since we don't want to intersperse with spaces.
        rq::ExprKind::SString(s_string_items) => {
            let text = translate_sstring(s_string_items, ctx)?;

            ExprOrSource::Source(SourceExpr {
                text,
                binding_strength: 100,
                window_frame: false,
            })
        }
        rq::ExprKind::Param(id) => ExprOrSource::Source(SourceExpr {
            text: format!("${id}"),
            binding_strength: 100,
            window_frame: false,
        }),
        rq::ExprKind::Literal(l) => translate_literal(l, ctx)?.into(),
        rq::ExprKind::Case(mut cases) => {
            let default = cases
                .last()
                .filter(|last| {
                    matches!(
                        last.condition.kind,
                        rq::ExprKind::Literal(Literal::Boolean(true))
                    )
                })
                .map(|def| translate_expr(def.value.clone(), ctx))
                .transpose()?
                .map(|x| x.into_ast());

            if default.is_some() {
                cases.pop();
            }

            let else_result = default
                .or(Some(sql_ast::Expr::Value(Value::Null.into())))
                .map(Box::new);

            let conditions = cases
                .into_iter()
                .map(|case| -> Result<_> {
                    let condition = translate_expr(case.condition, ctx)?.into_ast();
                    let result = translate_expr(case.value, ctx)?.into_ast();
                    Ok(sql_ast::CaseWhen { condition, result })
                })
                .try_collect()?;

            sql_ast::Expr::Case {
                case_token: sqlparser::ast::helpers::attached_token::AttachedToken::empty(),
                end_token: sqlparser::ast::helpers::attached_token::AttachedToken::empty(),
                operand: None,
                conditions,
                else_result,