Function like_op

arrow-string/src/like.rs:218–296

(op: Op, lhs: &dyn Datum, rhs: &dyn Datum)

}

fn like_op(op: Op, lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
    use arrow_schema::DataType::*;
    let (l, l_s) = lhs.get();
    let (r, r_s) = rhs.get();

    if l.len() != r.len() && !l_s && !r_s {
        return Err(ArrowError::InvalidArgumentError(format!(
            "Cannot compare arrays of different lengths, got {} vs {}",
            l.len(),
            r.len()
        )));
    }

    let l_v = l.as_any_dictionary_opt();
    let l = l_v.map(|x| x.values().as_ref()).unwrap_or(l);

    let r_v = r.as_any_dictionary_opt();
    let r = r_v.map(|x| x.values().as_ref()).unwrap_or(r);

    match (l.data_type(), r.data_type()) {
        (Utf8, Utf8) => string_apply::<&GenericStringArray<i32>>(
            op,
            l.as_string(),
            l_s,
            l_v,
            r.as_string(),
            r_s,
            r_v,
        ),
        (LargeUtf8, LargeUtf8) => string_apply::<&GenericStringArray<i64>>(
            op,
            l.as_string(),
            l_s,
            l_v,
            r.as_string(),
            r_s,
            r_v,
        ),
        (Utf8View, Utf8View) => string_apply::<&StringViewArray>(
            op,
            l.as_string_view(),
            l_s,
            l_v,
            r.as_string_view(),
            r_s,
            r_v,
        ),
        (Binary, Binary) => binary_apply::<&GenericBinaryArray<i32>>(
            op.try_into()?,
            l.as_binary(),
            l_s,
            l_v,
            r.as_binary(),
            r_s,
            r_v,
        ),
        (LargeBinary, LargeBinary) => binary_apply::<&GenericBinaryArray<i64>>(
            op.try_into()?,