Function process_concat

prqlc/prqlc/src/sql/gen_expr.rs:337–385

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

}

fn process_concat(expr: &rq::Expr, ctx: &mut Context) -> Result<sql_ast::Expr> {
    if ctx.dialect.has_concat_function() {
        let concat_args = collect_concat_args(expr);

        let args_list = concat_args
            .iter()
            .map(|a| {
                translate_expr((*a).clone(), ctx)
                    .map(|x| FunctionArg::Unnamed(FunctionArgExpr::Expr(x.into_ast())))
            })
            .try_collect()?;

        let args = sql_ast::FunctionArguments::List(FunctionArgumentList {
            args: args_list,
            clauses: vec![],
            duplicate_treatment: None,
        });

        Ok(sql_ast::Expr::Function(Function {
            name: ObjectName(vec![sqlparser::ast::ObjectNamePart::Identifier(
                sql_ast::Ident::new("CONCAT"),
            )]),
            args,
            over: None,
            filter: None,
            null_treatment: None,
            within_group: vec![],
            parameters: sql_ast::FunctionArguments::None,
            uses_odbc_syntax: false,
        }))
    } else {
        let concat_args = collect_concat_args(expr);

        let mut iter = concat_args.into_iter();
        let first_expr = iter.next().unwrap();
        let mut current_expr = translate_expr(first_expr.clone(), ctx)?.into_ast();

        for arg in iter {
            let translated_arg = translate_expr(arg.clone(), ctx)?.into_ast();
            current_expr = sql_ast::Expr::BinaryOp {
                left: Box::new(current_expr),
                op: BinaryOperator::StringConcat,
                right: Box::new(translated_arg),
            };
        }

        Ok(current_expr)
    }
}

fn translate_binary_operator(
    left: &rq::Expr,