// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.

//! Provide SQL's LIKE operators for Arrow's string arrays

use crate::predicate::Predicate;

use arrow_array::cast::AsArray;

use arrow_array::*;

use arrow_schema::*;

use arrow_select::take::take;

use std::sync::Arc;

use crate::binary_like::binary_apply;

pub use arrow_array::StringArrayType;

#[derive(Debug)]

pub(crate) enum Op {

    Like(bool),

    ILike(bool),

    Contains,

    StartsWith,

    EndsWith,

}

impl std::fmt::Display for Op {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        match self {

            Op::Like(false) => write!(f, "LIKE"),

            Op::Like(true) => write!(f, "NLIKE"),

            Op::ILike(false) => write!(f, "ILIKE"),

            Op::ILike(true) => write!(f, "NILIKE"),

            Op::Contains => write!(f, "CONTAINS"),

            Op::StartsWith => write!(f, "STARTS_WITH"),

            Op::EndsWith => write!(f, "ENDS_WITH"),

        }

    }

}

/// Perform SQL `left LIKE right`

///

/// # Supported DataTypes

///

/// `left` and `right` must be the same type, and one of

/// - Utf8

/// - LargeUtf8

/// - Utf8View

///

/// There are two wildcards supported with the LIKE operator:

///

/// 1. `%` - The percent sign represents zero, one, or multiple characters

/// 2. `_` - The underscore represents a single character

///

/// Example

/// ```

/// # use arrow_array::{StringArray, BooleanArray};

/// # use arrow_string::like::like;

/// let strings = StringArray::from(vec!["Arrow", "Arrow", "Arrow", "Ar"]);

/// let patterns = StringArray::from(vec!["A%", "B%", "A.", "A_"]);

///

/// let result = like(&strings, &patterns).unwrap();

/// assert_eq!(result, BooleanArray::from(vec![true, false, false, true]));

/// ```

pub fn like(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {

    like_op(Op::Like(false), left, right)

}

/// Perform SQL `left ILIKE right`

///

/// # Notes

/// - This is a case-insensitive version of [`like`]

/// - See the documentation on [`like`] for more details

/// - Implements loose matching as defined by the Unicode standard. For example,

///   the `ff` ligature is not equivalent to `FF` and `ß` is not equivalent to `SS`

pub fn ilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {

    like_op(Op::ILike(false), left, right)

}

/// Perform SQL `left NOT LIKE right`

///

/// # Notes

/// - This is a negative of [`like`]

/// - See the documentation on [`like`] for more details

pub fn nlike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {

    like_op(Op::Like(true), left, right)

}

/// Perform SQL `left NOT ILIKE right`

///

/// # Notes

/// - This is a negative of [`like`]

/// - See the documentation on [`ilike`] for more details

pub fn nilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {

    like_op(Op::ILike(true), left, right)

}

/// Perform SQL `STARTSWITH(left, right)`

///

/// # Supported DataTypes

///

/// `left` and `right` must be the same type, and one of

/// - Utf8

/// - LargeUtf8

/// - Utf8View

/// - Binary

/// - LargeBinary

/// - BinaryView

///

/// # Example

/// ```

/// # use arrow_array::{StringArray, BooleanArray};

/// # use arrow_string::like::{like, starts_with};

/// let strings = StringArray::from(vec!["arrow-rs", "arrow-rs", "arrow-rs", "Parquet"]);

/// let patterns = StringArray::from(vec!["arr", "arrow", "arrow-cpp", "p"]);

///

/// let result = starts_with(&strings, &patterns).unwrap();

/// assert_eq!(result, BooleanArray::from(vec![true, true, false, false]));

/// ```

pub fn starts_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {

    like_op(Op::StartsWith, left, right)

}

/// Perform SQL `ENDSWITH(left, right)`

///

/// # Supported DataTypes

///

/// `left` and `right` must be the same type, and one of

/// - Utf8

/// - LargeUtf8

/// - Utf8View

/// - Binary

/// - LargeBinary

/// - BinaryView

///

/// # Example

/// ```

/// # use arrow_array::{StringArray, BooleanArray};

/// # use arrow_string::like::{ends_with, like, starts_with};

/// let strings = StringArray::from(vec!["arrow-rs", "arrow-rs",  "Parquet"]);

/// let patterns = StringArray::from(vec!["arr", "-rs", "t"]);

///

/// let result = ends_with(&strings, &patterns).unwrap();

/// assert_eq!(result, BooleanArray::from(vec![false, true, true]));

/// ```

pub fn ends_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {

    like_op(Op::EndsWith, left, right)

}

/// Perform SQL `CONTAINS(left, right)`

///

/// # Supported DataTypes

///

/// `left` and `right` must be the same type, and one of

/// - Utf8

/// - LargeUtf8

/// - Utf8View

/// - Binary

/// - LargeBinary

/// - BinaryView

///

/// # Example

/// ```

/// # use arrow_array::{StringArray, BooleanArray};

/// # use arrow_string::like::{contains, like, starts_with};

/// let strings = StringArray::from(vec!["arrow-rs", "arrow-rs", "arrow-rs", "Parquet"]);

/// let patterns = StringArray::from(vec!["arr", "-rs", "arrow-cpp", "X"]);

///

/// let result = contains(&strings, &patterns).unwrap();

/// assert_eq!(result, BooleanArray::from(vec![true, true, false, false]));

/// ```

pub fn contains(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {

    like_op(Op::Contains, left, right)

}

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()?,

            l.as_binary(),

            l_s,

            l_v,

            r.as_binary(),

            r_s,

            r_v,

        ),

        (BinaryView, BinaryView) => binary_apply::<&BinaryViewArray>(

            op.try_into()?,

            l.as_binary_view(),

            l_s,

            l_v,

            r.as_binary_view(),

            r_s,

            r_v,

        ),

        (l_t, r_t) => Err(ArrowError::InvalidArgumentError(format!(

            "Invalid string/binary operation: {l_t} {op} {r_t}"

        ))),

    }

}

fn string_apply<'a, T: StringArrayType<'a> + 'a>(

    op: Op,

    l: T,

    l_s: bool,

    l_v: Option<&'a dyn AnyDictionaryArray>,

    r: T,

    r_s: bool,

    r_v: Option<&'a dyn AnyDictionaryArray>,

) -> Result<BooleanArray, ArrowError> {

    let l_len = l_v.map(|l| l.len()).unwrap_or(l.len());

    if r_s {

        let idx = match r_v {

            Some(dict) if dict.null_count() != 0 => return Ok(BooleanArray::new_null(l_len)),

            Some(dict) => dict.normalized_keys()[0],

            None => 0,

        };

        if r.is_null(idx) {

            return Ok(BooleanArray::new_null(l_len));

        }

        op_scalar::<T>(op, l, l_v, r.value(idx))

    } else {

        match (l_s, l_v, r_v) {

            (true, None, None) => {

                let v = l.is_valid(0).then(|| l.value(0));

                op_binary(op, std::iter::repeat(v), r.iter())

            }

            (true, Some(l_v), None) => {

                let idx = l_v.is_valid(0).then(|| l_v.normalized_keys()[0]);

                let v = idx.and_then(|idx| l.is_valid(idx).then(|| l.value(idx)));

                op_binary(op, std::iter::repeat(v), r.iter())

            }

            (true, None, Some(r_v)) => {

                let v = l.is_valid(0).then(|| l.value(0));

                op_binary(op, std::iter::repeat(v), vectored_iter(r, r_v))

            }

            (true, Some(l_v), Some(r_v)) => {

                let idx = l_v.is_valid(0).then(|| l_v.normalized_keys()[0]);

                let v = idx.and_then(|idx| l.is_valid(idx).then(|| l.value(idx)));

                op_binary(op, std::iter::repeat(v), vectored_iter(r, r_v))

            }

            (false, None, None) => op_binary(op, l.iter(), r.iter()),

            (false, Some(l_v), None) => op_binary(op, vectored_iter(l, l_v), r.iter()),

            (false, None, Some(r_v)) => op_binary(op, l.iter(), vectored_iter(r, r_v)),

            (false, Some(l_v), Some(r_v)) => {

                op_binary(op, vectored_iter(l, l_v), vectored_iter(r, r_v))

            }

        }

    }

}

#[inline(never)]

fn op_scalar<'a, T: StringArrayType<'a>>(

    op: Op,

    l: T,

    l_v: Option<&dyn AnyDictionaryArray>,

    r: &str,

) -> Result<BooleanArray, ArrowError> {

    let r = match op {

        Op::Like(neg) => Predicate::like(r)?.evaluate_array(l, neg),

        Op::ILike(neg) => Predicate::ilike(r, l.is_ascii())?.evaluate_array(l, neg),

        Op::Contains => Predicate::contains(r).evaluate_array(l, false),

        Op::StartsWith => Predicate::StartsWith(r).evaluate_array(l, false),

        Op::EndsWith => Predicate::EndsWith(r).evaluate_array(l, false),

    };

    Ok(match l_v {

        Some(v) => take(&r, v.keys(), None)?.as_boolean().clone(),

        None => r,

    })

}

fn vectored_iter<'a, T: StringArrayType<'a> + 'a>(

    a: T,

    a_v: &'a dyn AnyDictionaryArray,

) -> impl Iterator<Item = Option<&'a str>> + 'a {

    let nulls = a_v.nulls();

    let keys = a_v.normalized_keys();

    keys.into_iter().enumerate().map(move |(idx, key)| {

        if nulls.map(|n| n.is_null(idx)).unwrap_or_default() || a.is_null(key) {

            return None;

        }

        Some(a.value(key))

    })

}

#[inline(never)]

fn op_binary<'a>(

    op: Op,

    l: impl Iterator<Item = Option<&'a str>>,

    r: impl Iterator<Item = Option<&'a str>>,

) -> Result<BooleanArray, ArrowError> {

    match op {

        Op::Like(neg) => binary_predicate(l, r, neg, Predicate::like),

        Op::ILike(neg) => binary_predicate(l, r, neg, |s| Predicate::ilike(s, false)),

        Op::Contains => Ok(l.zip(r).map(|(l, r)| Some(str_contains(l?, r?))).collect()),

        Op::StartsWith => Ok(l

            .zip(r)

            .map(|(l, r)| Some(Predicate::StartsWith(r?).evaluate(l?)))

            .collect()),

        Op::EndsWith => Ok(l

            .zip(r)

            .map(|(l, r)| Some(Predicate::EndsWith(r?).evaluate(l?)))

            .collect()),

    }

}

fn str_contains(haystack: &str, needle: &str) -> bool {

    memchr::memmem::find(haystack.as_bytes(), needle.as_bytes()).is_some()

}

fn binary_predicate<'a>(

    l: impl Iterator<Item = Option<&'a str>>,

    r: impl Iterator<Item = Option<&'a str>>,

    neg: bool,

    f: impl Fn(&'a str) -> Result<Predicate<'a>, ArrowError>,

) -> Result<BooleanArray, ArrowError> {

    let mut previous = None;

    l.zip(r)

        .map(|(l, r)| match (l, r) {

            (Some(l), Some(r)) => {

                let p: &Predicate = match previous {

                    Some((expr, ref predicate)) if expr == r => predicate,

                    _ => &previous.insert((r, f(r)?)).1,

                };

                Ok(Some(p.evaluate(l) != neg))

            }

            _ => Ok(None),

        })

        .collect()

}

// Deprecated kernels

fn make_scalar(data_type: &DataType, scalar: &str) -> Result<ArrayRef, ArrowError> {

    match data_type {

        DataType::Utf8 => Ok(Arc::new(StringArray::from_iter_values([scalar]))),

        DataType::LargeUtf8 => Ok(Arc::new(LargeStringArray::from_iter_values([scalar]))),

        DataType::Dictionary(_, v) => make_scalar(v.as_ref(), scalar),

        d => Err(ArrowError::InvalidArgumentError(format!(

            "Unsupported string scalar data type {d:?}",

        ))),

    }

}

macro_rules! legacy_kernels {

    ($fn_datum:ident, $fn_array:ident, $fn_scalar:ident, $fn_array_dyn:ident, $fn_scalar_dyn:ident, $deprecation:expr) => {

        #[doc(hidden)]

        #[deprecated(note = $deprecation)]

        pub fn $fn_array<O: OffsetSizeTrait>(

            left: &GenericStringArray<O>,

            right: &GenericStringArray<O>,

        ) -> Result<BooleanArray, ArrowError> {

            $fn_datum(left, right)

        }

        #[doc(hidden)]

        #[deprecated(note = $deprecation)]

        pub fn $fn_scalar<O: OffsetSizeTrait>(

            left: &GenericStringArray<O>,

            right: &str,

        ) -> Result<BooleanArray, ArrowError> {

            let scalar = GenericStringArray::<O>::from_iter_values([right]);

            $fn_datum(left, &Scalar::new(&scalar))

        }

        #[doc(hidden)]

        #[deprecated(note = $deprecation)]

        pub fn $fn_array_dyn(

            left: &dyn Array,

            right: &dyn Array,

        ) -> Result<BooleanArray, ArrowError> {

            $fn_datum(&left, &right)

        }

        #[doc(hidden)]

        #[deprecated(note = $deprecation)]

        pub fn $fn_scalar_dyn(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {

            let scalar = make_scalar(left.data_type(), right)?;

            $fn_datum(&left, &Scalar::new(&scalar))

        }

    };

}

legacy_kernels!(

    like,

    like_utf8,

    like_utf8_scalar,

    like_dyn,

    like_utf8_scalar_dyn,

    "Use arrow_string::like::like"

);

legacy_kernels!(

    ilike,

    ilike_utf8,

    ilike_utf8_scalar,

    ilike_dyn,

    ilike_utf8_scalar_dyn,

    "Use arrow_string::like::ilike"

);

legacy_kernels!(

    nlike,

    nlike_utf8,

    nlike_utf8_scalar,

    nlike_dyn,

    nlike_utf8_scalar_dyn,

    "Use arrow_string::like::nlike"

);

legacy_kernels!(

    nilike,

    nilike_utf8,

    nilike_utf8_scalar,

    nilike_dyn,

    nilike_utf8_scalar_dyn,

    "Use arrow_string::like::nilike"

);

legacy_kernels!(

    contains,

    contains_utf8,

    contains_utf8_scalar,

    contains_dyn,

    contains_utf8_scalar_dyn,

    "Use arrow_string::like::contains"

);

legacy_kernels!(

    starts_with,

    starts_with_utf8,

    starts_with_utf8_scalar,

    starts_with_dyn,

    starts_with_utf8_scalar_dyn,

    "Use arrow_string::like::starts_with"

);

legacy_kernels!(

    ends_with,

    ends_with_utf8,

    ends_with_utf8_scalar,

    ends_with_dyn,

    ends_with_utf8_scalar_dyn,

    "Use arrow_string::like::ends_with"

);

#[cfg(test)]

#[allow(deprecated)]

mod tests {

    use super::*;

    use arrow_array::builder::BinaryDictionaryBuilder;

    use arrow_array::types::{ArrowDictionaryKeyType, Int8Type};

    use std::iter::zip;

    fn convert_binary_iterator_to_binary_dictionary<

        'a,

        K: ArrowDictionaryKeyType,

        I: IntoIterator<Item = &'a [u8]>,

    >(

        iter: I,

    ) -> DictionaryArray<K> {

        let it = iter.into_iter();

        let (lower, _) = it.size_hint();

        let mut builder = BinaryDictionaryBuilder::with_capacity(lower, 256, 1024);

        it.for_each(|i| {

            builder

                .append(i)

                .expect("Unable to append a value to a dictionary array.");

        });

        builder.finish()

    }

    /// Applying `op(left, right)`, both sides are arrays

    /// The macro tests four types of array implementations:

    /// - `StringArray`

    /// - `LargeStringArray`

    /// - `StringViewArray`

    /// - `DictionaryArray`

    macro_rules! test_utf8 {

        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {

            #[test]

            fn $test_name() {

                let expected = BooleanArray::from($expected);

                let left = StringArray::from($left);

                let right = StringArray::from($right);

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left = LargeStringArray::from($left);

                let right = LargeStringArray::from($right);

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left = StringViewArray::from($left);

                let right = StringViewArray::from($right);

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();

                let right: DictionaryArray<Int8Type> = $right.into_iter().collect();

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

            }

        };

    }

    /// Applying `op(left, right)`, both sides are arrays

    /// The macro tests four types of array implementations:

    /// - `StringArray`

    /// - `LargeStringArray`

    /// - `StringViewArray`

    /// - `DictionaryArray`

    macro_rules! test_utf8_and_binary {

        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {

            #[test]

            fn $test_name() {

                let expected = BooleanArray::from($expected);

                let left = StringArray::from($left);

                let right = StringArray::from($right);

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left = LargeStringArray::from($left);

                let right = LargeStringArray::from($right);

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left = StringViewArray::from($left);

                let right = StringViewArray::from($right);

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();

                let right: DictionaryArray<Int8Type> = $right.into_iter().collect();

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left_binary = $left.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();

                let right_binary = $right.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();

                let left = BinaryArray::from(left_binary.clone());

                let right = BinaryArray::from(right_binary.clone());

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left = LargeBinaryArray::from(left_binary.clone());

                let right = LargeBinaryArray::from(right_binary.clone());

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

                let left: DictionaryArray<Int8Type> =

                    convert_binary_iterator_to_binary_dictionary(left_binary);

                let right: DictionaryArray<Int8Type> =

                    convert_binary_iterator_to_binary_dictionary(right_binary);

                let res = $op(&left, &right).unwrap();

                assert_eq!(res, expected);

            }

        };

    }

    /// Applying `op(left, right)`, left side is array, right side is scalar

    /// The macro tests four types of array implementations:

    /// - `StringArray`

    /// - `LargeStringArray`

    /// - `StringViewArray`

    /// - `DictionaryArray`

    macro_rules! test_utf8_scalar {

        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {

            #[test]

            fn $test_name() {

                let expected = BooleanArray::from($expected);

                let left = StringArray::from($left);

                let right = StringArray::from_iter_values([$right]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left = LargeStringArray::from($left);

                let right = LargeStringArray::from_iter_values([$right]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left = StringViewArray::from($left);

                let right = StringViewArray::from_iter_values([$right]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();

                let right: DictionaryArray<Int8Type> = [$right].into_iter().collect();

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

            }

        };

    }

    /// Applying `op(left, right)`, left side is array, right side is scalar

    /// The macro tests four types of array implementations:

    /// - `StringArray`

    /// - `LargeStringArray`

    /// - `StringViewArray`

    /// - `DictionaryArray`

    macro_rules! test_utf8_and_binary_scalar {

        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {

            #[test]

            fn $test_name() {

                let expected = BooleanArray::from($expected);

                let left = StringArray::from($left);

                let right = StringArray::from_iter_values([$right]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left = LargeStringArray::from($left);

                let right = LargeStringArray::from_iter_values([$right]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left = StringViewArray::from($left);

                let right = StringViewArray::from_iter_values([$right]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();

                let right: DictionaryArray<Int8Type> = [$right].into_iter().collect();

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left_binary = $left.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();

                let right_binary = $right.as_bytes();

                let left = BinaryArray::from(left_binary.clone());

                let right = BinaryArray::from_iter_values([right_binary]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left = LargeBinaryArray::from(left_binary.clone());

                let right = LargeBinaryArray::from_iter_values([right_binary]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

                let left: DictionaryArray<Int8Type> =

                    convert_binary_iterator_to_binary_dictionary(left_binary);

                let right: DictionaryArray<Int8Type> =

                    convert_binary_iterator_to_binary_dictionary([right_binary]);

                let res = $op(&left, &Scalar::new(&right)).unwrap();

                assert_eq!(res, expected);

            }

        };

    }

    test_utf8!(

        test_utf8_array_like,

        vec![

            "arrow",

            "arrow_long_string_more than 12 bytes",

            "arrow",

            "arrow",

            "arrow",

            "arrows",

            "arrow",

            "arrow"

        ],

        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_", ".*"],

        like,

        vec![true, true, true, false, false, true, false, false]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar_escape_testing,

        vec![

            "varchar(255)",

            "int(255)longer than 12 bytes",

            "varchar",

            "int"

        ],

        "%(%)%",

        like,

        vec![true, true, false, false]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar_escape_regex,

        vec![".*", "a", "*"],

        ".*",

        like,

        vec![true, false, false]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar_escape_regex_dot,

        vec![".", "a", "*"],

        ".",

        like,

        vec![true, false, false]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar,

        vec![

            "arrow",

            "parquet",

            "datafusion",

            "flight",

            "long string arrow test 12 bytes"

        ],

        "%ar%",

        like,

        vec![true, true, false, false, true]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar_start,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "arrow%",

        like,

        vec![true, false, true, false, true]

    );

    // Replicates `test_utf8_array_like_scalar_start` `test_utf8_array_like_scalar_dyn_start` to

    // demonstrate that `SQL STARTSWITH` works as expected.

    test_utf8_and_binary_scalar!(

        test_utf8_and_binary_array_starts_with_scalar_start,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "arrow",

        starts_with,

        vec![true, false, true, false, true]

    );

    test_utf8_and_binary!(

        test_utf8_and_binary_array_starts_with,

        vec![

            "arrow",

            "arrow_long_string_more than 12 bytes",

            "arrow",

            "arrow",

            "arrow",

            "arrows",

            "arrow",

            "arrow"

        ],

        vec!["arrow", "ar%", "row", "foo", "arr", "arrow_", "arrow_", ".*"],

        starts_with,

        vec![true, false, false, false, true, false, false, false]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar_end,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "%arrow",

        like,

        vec![true, true, false, false, false]

    );

    // Replicates `test_utf8_array_like_scalar_end` `test_utf8_array_like_scalar_dyn_end` to

    // demonstrate that `SQL ENDSWITH` works as expected.

    test_utf8_and_binary_scalar!(

        test_utf8_and_binary_array_ends_with_scalar_end,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "arrow",

        ends_with,

        vec![true, true, false, false, false]

    );

    test_utf8_and_binary!(

        test_utf8_and_binary_array_ends_with,

        vec![

            "arrow",

            "arrow_long_string_more than 12 bytes",

            "arrow",

            "arrow",

            "arrow",

            "arrows",

            "arrow",

            "arrow"

        ],

        vec!["arrow", "ar%", "row", "foo", "arr", "arrow_", "arrow_", ".*"],

        ends_with,

        vec![true, false, true, false, false, false, false, false]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar_equals,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "arrow",

        like,

        vec![true, false, false, false, false]

    );

    test_utf8_scalar!(

        test_utf8_array_like_scalar_one,

        vec![

            "arrow",

            "arrows",

            "parrow",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "arrow_",

        like,

        vec![false, true, false, false, false]

    );

    test_utf8_scalar!(

        test_utf8_scalar_like_escape,

        vec!["a%", "a\\x", "arrow long string longer than 12 bytes"],

        "a\\%",

        like,

        vec![true, false, false]

    );

    test_utf8_scalar!(

        test_utf8_scalar_like_escape_contains,

        vec!["ba%", "ba\\x", "arrow long string longer than 12 bytes"],

        "%a\\%",

        like,

        vec![true, false, false]

    );

    test_utf8!(

        test_utf8_scalar_ilike_regex,

        vec!["%%%"],

        vec![r"\%_\%"],

        ilike,

        vec![true]

    );

    test_utf8!(

        test_utf8_array_nlike,

        vec![

            "arrow",

            "arrow",

            "arrow long string longer than 12 bytes",

            "arrow",

            "arrow",

            "arrows",

            "arrow"

        ],

        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_"],

        nlike,

        vec![false, false, false, true, true, false, true]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_escape_testing,

        vec![

            "varchar(255)",

            "int(255) arrow long string longer than 12 bytes",

            "varchar",

            "int"

        ],

        "%(%)%",

        nlike,

        vec![false, false, true, true]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_scalar_escape_regex,

        vec![".*", "a", "*"],

        ".*",

        nlike,

        vec![false, true, true]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_scalar_escape_regex_dot,

        vec![".", "a", "*"],

        ".",

        nlike,

        vec![false, true, true]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_scalar,

        vec![

            "arrow",

            "parquet",

            "datafusion",

            "flight",

            "arrow long string longer than 12 bytes"

        ],

        "%ar%",

        nlike,

        vec![false, false, true, true, false]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_scalar_start,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "arrow%",

        nlike,

        vec![false, true, false, true, false]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_scalar_end,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "%arrow",

        nlike,

        vec![false, false, true, true, true]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_scalar_equals,

        vec![

            "arrow",

            "parrow",

            "arrows",

            "arr",

            "arrow long string longer than 12 bytes"

        ],

        "arrow",

        nlike,

        vec![false, true, true, true, true]

    );

    test_utf8_scalar!(

        test_utf8_array_nlike_scalar_one,

        vec![

            "arrow",

            "arrows",

            "parrow",

            "arr",

            "arrow long string longer than 12 bytes"

        ],