Function simplify_concat_ws

datafusion/functions/src/string/concat_ws.rs:401–521

(delimiter: &Expr, args: &[Expr])

}

fn simplify_concat_ws(delimiter: &Expr, args: &[Expr]) -> Result<ExprSimplifyResult> {
    // Preserve the delimiter's string type for any new literals produced
    // during simplification.
    let delimiter_type = match delimiter {
        Expr::Literal(v, _) => v.data_type(),
        _ => DataType::Utf8,
    };

    let typed_lit = |s: String| -> Expr {
        match delimiter_type {
            DataType::LargeUtf8 => lit(ScalarValue::LargeUtf8(Some(s))),
            DataType::Utf8View => lit(ScalarValue::Utf8View(Some(s))),
            _ => lit(s),
        }
    };

    match delimiter {
        Expr::Literal(
            ScalarValue::Utf8(delimiter)
            | ScalarValue::LargeUtf8(delimiter)
            | ScalarValue::Utf8View(delimiter),
            _,
        ) => {
            match delimiter {
                // When the delimiter is the empty string, replace `concat_ws`
                // with `concat`
                Some(delimiter) if delimiter.is_empty() => {
                    match simplify_concat(args.to_vec())? {
                        ExprSimplifyResult::Original(_) => {
                            Ok(ExprSimplifyResult::Simplified(Expr::ScalarFunction(
                                ScalarFunction {
                                    func: concat(),
                                    args: args.to_vec(),
                                },
                            )))
                        }
                        expr => Ok(expr),
                    }
                }
                Some(delimiter) => {
                    let mut new_args = Vec::with_capacity(args.len());
                    new_args.push(typed_lit(delimiter.to_string()));
                    let mut contiguous_scalar = None;
                    for arg in args {
                        match arg {
                            // filter out null args
                            Expr::Literal(
                                ScalarValue::Utf8(None)
                                | ScalarValue::LargeUtf8(None)
                                | ScalarValue::Utf8View(None),
                                _,
                            ) => {}
                            Expr::Literal(
                                ScalarValue::Utf8(Some(v))
                                | ScalarValue::LargeUtf8(Some(v))
                                | ScalarValue::Utf8View(Some(v)),
                                _,
                            ) => match contiguous_scalar {