Skip to main content

arrow_string/
like.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for additional information regarding copyright ownership
3// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
4
5//! String predicate kernels for Arrow arrays.
6//!
7//! Provides SQL `LIKE`/`ILIKE` kernels as well as related
8//! string predicates such as `contains`, `starts_with`, `ends_with`, and
9//! ASCII case-insensitive equality.
10
11use crate::predicate::Predicate;
12
13use arrow_array::builder::BooleanBuilder;
14use arrow_array::cast::AsArray;
15use arrow_array::types::{ArrowDictionaryKeyType, RunEndIndexType};
16use arrow_array::*;
17use arrow_buffer::ArrowNativeType;
18use arrow_schema::*;
19use arrow_select::take::take;
20use std::sync::Arc;
21
22use crate::binary_like::binary_apply;
23pub use arrow_array::StringArrayType;
24
25#[derive(Debug)]
26pub(crate) enum Op {
27    Like(bool),
28    ILike(bool),
29    Contains,
30    EqIgnoreAsciiCase,
31    StartsWith,
32    EndsWith,
33}
34
35impl std::fmt::Display for Op {
36    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37        match self {
38            Op::Like(false) => write!(f, "LIKE"),
39            Op::Like(true) => write!(f, "NLIKE"),
40            Op::ILike(false) => write!(f, "ILIKE"),
41            Op::ILike(true) => write!(f, "NILIKE"),
42            Op::Contains => write!(f, "CONTAINS"),
43            Op::EqIgnoreAsciiCase => write!(f, "EQ_IGNORE_ASCII_CASE"),
44            Op::StartsWith => write!(f, "STARTS_WITH"),
45            Op::EndsWith => write!(f, "ENDS_WITH"),
46        }
47    }
48}
49
50/// Perform SQL `left LIKE right`
51///
52/// # Supported DataTypes
53///
54/// `left` and `right` must be the same type, and one of
55/// - Utf8
56/// - LargeUtf8
57/// - Utf8View
58///
59/// Either operand may be dictionary or run-end encoded, including dictionary-encoded
60/// run values, as long as the underlying value types match.
61///
62/// There are two wildcards supported with the LIKE operator:
63///
64/// 1. `%` - The percent sign represents zero, one, or multiple characters
65/// 2. `_` - The underscore represents a single character
66///
67/// Example
68/// ```
69/// # use arrow_array::{StringArray, BooleanArray};
70/// # use arrow_string::like::like;
71/// let strings = StringArray::from(vec!["Arrow", "Arrow", "Arrow", "Ar"]);
72/// let patterns = StringArray::from(vec!["A%", "B%", "A.", "A_"]);
73///
74/// let result = like(&strings, &patterns).unwrap();
75/// assert_eq!(result, BooleanArray::from(vec![true, false, false, true]));
76/// ```
77pub fn like(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
78    like_op(Op::Like(false), left, right)
79}
80
81/// Perform SQL `left ILIKE right`
82///
83/// # Notes
84/// - This is a case-insensitive version of [`like`]
85/// - See the documentation on [`like`] for more details
86/// - Implements loose matching as defined by the Unicode standard. For example,
87///   the `ff` ligature is not equivalent to `FF` and `ß` is not equivalent to `SS`
88pub fn ilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
89    like_op(Op::ILike(false), left, right)
90}
91
92/// Perform SQL `left NOT LIKE right`
93///
94/// # Notes
95/// - This is a negative of [`like`]
96/// - See the documentation on [`like`] for more details
97pub fn nlike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
98    like_op(Op::Like(true), left, right)
99}
100
101/// Perform SQL `left NOT ILIKE right`
102///
103/// # Notes
104/// - This is a negative of [`like`]
105/// - See the documentation on [`ilike`] for more details
106pub fn nilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
107    like_op(Op::ILike(true), left, right)
108}
109
110/// Perform SQL `STARTSWITH(left, right)`
111///
112/// # Supported DataTypes
113///
114/// `left` and `right` must be the same type, and one of
115/// - Utf8
116/// - LargeUtf8
117/// - Utf8View
118/// - Binary
119/// - LargeBinary
120/// - BinaryView
121///
122/// Either operand may be dictionary or run-end encoded, including dictionary-encoded
123/// run values, as long as the underlying value types match.
124///
125/// # Example
126/// ```
127/// # use arrow_array::{StringArray, BooleanArray};
128/// # use arrow_string::like::starts_with;
129/// let strings = StringArray::from(vec!["arrow-rs", "arrow-rs", "arrow-rs", "Parquet"]);
130/// let patterns = StringArray::from(vec!["arr", "arrow", "arrow-cpp", "p"]);
131///
132/// let result = starts_with(&strings, &patterns).unwrap();
133/// assert_eq!(result, BooleanArray::from(vec![true, true, false, false]));
134/// ```
135pub fn starts_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
136    like_op(Op::StartsWith, left, right)
137}
138
139/// Perform SQL `ENDSWITH(left, right)`
140///
141/// # Supported DataTypes
142///
143/// `left` and `right` must be the same type, and one of
144/// - Utf8
145/// - LargeUtf8
146/// - Utf8View
147/// - Binary
148/// - LargeBinary
149/// - BinaryView
150///
151/// Either operand may be dictionary or run-end encoded, including dictionary-encoded
152/// run values, as long as the underlying value types match.
153///
154/// # Example
155/// ```
156/// # use arrow_array::{StringArray, BooleanArray};
157/// # use arrow_string::like::ends_with;
158/// let strings = StringArray::from(vec!["arrow-rs", "arrow-rs",  "Parquet"]);
159/// let patterns = StringArray::from(vec!["arr", "-rs", "t"]);
160///
161/// let result = ends_with(&strings, &patterns).unwrap();
162/// assert_eq!(result, BooleanArray::from(vec![false, true, true]));
163/// ```
164pub fn ends_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
165    like_op(Op::EndsWith, left, right)
166}
167
168/// Perform SQL `CONTAINS(left, right)`
169///
170/// # Supported DataTypes
171///
172/// `left` and `right` must be the same type, and one of
173/// - Utf8
174/// - LargeUtf8
175/// - Utf8View
176/// - Binary
177/// - LargeBinary
178/// - BinaryView
179///
180/// Either operand may be dictionary or run-end encoded, including dictionary-encoded
181/// run values, as long as the underlying value types match.
182///
183/// # Example
184/// ```
185/// # use arrow_array::{StringArray, BooleanArray};
186/// # use arrow_string::like::contains;
187/// let strings = StringArray::from(vec!["arrow-rs", "arrow-rs", "arrow-rs", "Parquet"]);
188/// let patterns = StringArray::from(vec!["arr", "-rs", "arrow-cpp", "X"]);
189///
190/// let result = contains(&strings, &patterns).unwrap();
191/// assert_eq!(result, BooleanArray::from(vec![true, true, false, false]));
192/// ```
193pub fn contains(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
194    like_op(Op::Contains, left, right)
195}
196
197/// Perform equality check on two arrays using an ASCII case-insensitive match.
198///
199/// `left` and `right` must be the same type, and one of
200/// - Utf8
201/// - LargeUtf8
202/// - Utf8View
203///
204/// Either operand may be dictionary or run-end encoded, including dictionary-encoded
205/// run values, as long as the underlying value types match.
206///
207/// # Example
208/// ```
209/// # use arrow_array::{StringArray, BooleanArray};
210/// # use arrow_string::like::eq_ignore_ascii_case;
211/// let strings = StringArray::from(vec!["arrow", "rs", "arrow-rS", "Parquet"]);
212/// let patterns = StringArray::from(vec!["ARROW", "rS", "ARROW-rs", "arrow"]);
213///
214/// let result = eq_ignore_ascii_case(&strings, &patterns).unwrap();
215/// assert_eq!(result, BooleanArray::from(vec![true, true, true, false]));
216/// ```
217pub fn eq_ignore_ascii_case(
218    left: &dyn Datum,
219    right: &dyn Datum,
220) -> Result<BooleanArray, ArrowError> {
221    like_op(Op::EqIgnoreAsciiCase, left, right)
222}
223
224fn like_op(op: Op, lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
225    use arrow_schema::DataType::*;
226    let (l, l_s) = lhs.get();
227    let (r, r_s) = rhs.get();
228
229    if l.len() != r.len() && !l_s && !r_s {
230        return Err(ArrowError::InvalidArgumentError(format!(
231            "Cannot compare arrays of different lengths, got {} vs {}",
232            l.len(),
233            r.len()
234        )));
235    }
236
237    if l.as_any_ree_opt().is_some() || r.as_any_ree_opt().is_some() {
238        return run_end_encoded_op(op, lhs, rhs);
239    }
240
241    let l_v = l.as_any_dictionary_opt();
242    let l = l_v.map(|x| x.values().as_ref()).unwrap_or(l);
243
244    let r_v = r.as_any_dictionary_opt();
245    let r = r_v.map(|x| x.values().as_ref()).unwrap_or(r);
246
247    match (l.data_type(), r.data_type()) {
248        (Utf8, Utf8) => string_apply::<&GenericStringArray<i32>>(
249            op,
250            l.as_string(),
251            l_s,
252            l_v,
253            r.as_string(),
254            r_s,
255            r_v,
256        ),
257        (LargeUtf8, LargeUtf8) => string_apply::<&GenericStringArray<i64>>(
258            op,
259            l.as_string(),
260            l_s,
261            l_v,
262            r.as_string(),
263            r_s,
264            r_v,
265        ),
266        (Utf8View, Utf8View) => string_apply::<&StringViewArray>(
267            op,
268            l.as_string_view(),
269            l_s,
270            l_v,
271            r.as_string_view(),
272            r_s,
273            r_v,
274        ),
275        (Binary, Binary) => binary_apply::<&GenericBinaryArray<i32>>(
276            op.try_into()?,
277            l.as_binary(),
278            l_s,
279            l_v,
280            r.as_binary(),
281            r_s,
282            r_v,
283        ),
284        (LargeBinary, LargeBinary) => binary_apply::<&GenericBinaryArray<i64>>(
285            op.try_into()?,
286            l.as_binary(),
287            l_s,
288            l_v,
289            r.as_binary(),
290            r_s,
291            r_v,
292        ),
293        (BinaryView, BinaryView) => binary_apply::<&BinaryViewArray>(
294            op.try_into()?,
295            l.as_binary_view(),
296            l_s,
297            l_v,
298            r.as_binary_view(),
299            r_s,
300            r_v,
301        ),
302        (l_t, r_t) => Err(ArrowError::InvalidArgumentError(format!(
303            "Invalid string/binary operation: {l_t} {op} {r_t}"
304        ))),
305    }
306}
307
308/// Rewrites run-end encoded operands into encodings that [`like_op`] already supports,
309/// so value types, nulls and errors behave as they do without run-end encoding.
310fn run_end_encoded_op(
311    op: Op,
312    lhs: &dyn Datum,
313    rhs: &dyn Datum,
314) -> Result<BooleanArray, ArrowError> {
315    let (left, left_is_scalar) = lhs.get();
316    let (right, right_is_scalar) = rhs.get();
317    let left_is_ree = left.as_any_ree_opt().is_some();
318    let right_is_ree = right.as_any_ree_opt().is_some();
319    if left_is_ree && left_is_scalar {
320        // A scalar's only logical value is its only physical value.
321        like_op(op, &Scalar::new(run_values(left)), rhs)
322    } else if right_is_ree && right_is_scalar {
323        like_op(op, lhs, &Scalar::new(run_values(right)))
324    } else if right_is_scalar {
325        // Against a scalar every row of a run has the same result, so match each
326        // run once and repeat its result.
327        Ok(expand_runs(left, &like_op(op, &run_values(left), rhs)?))
328    } else if left_is_scalar {
329        Ok(expand_runs(right, &like_op(op, lhs, &run_values(right))?))
330    } else {
331        // Rows of two arrays need not share run boundaries, so look up each row
332        // through a dictionary view, which does not copy the values.
333        let left_dictionary = left_is_ree
334            .then(|| run_end_encoded_as_dictionary(left))
335            .transpose()?;
336        let right_dictionary = right_is_ree
337            .then(|| run_end_encoded_as_dictionary(right))
338            .transpose()?;
339        let lhs: &dyn Datum = left_dictionary
340            .as_ref()
341            .map_or(lhs, |dictionary| dictionary);
342        let rhs: &dyn Datum = right_dictionary
343            .as_ref()
344            .map_or(rhs, |dictionary| dictionary);
345        like_op(op, lhs, rhs)
346    }
347}
348
349/// Returns the physical values of the runs that a run-end encoded array's slice covers.
350fn run_values(array: &dyn Array) -> ArrayRef {
351    downcast_run_array!(
352        array => array.values_slice(),
353        _ => unreachable!("expected a run-end encoded array")
354    )
355}
356
357/// Repeats each run's result, as computed over [`run_values`], for every row of the run.
358fn expand_runs(array: &dyn Array, run_results: &BooleanArray) -> BooleanArray {
359    downcast_run_array!(
360        array => {
361            let mut builder = BooleanBuilder::with_capacity(array.len());
362            let mut run_start = 0;
363            for (run_result, run_end) in run_results.iter().zip(array.run_ends().sliced_values()) {
364                let run_end = run_end.as_usize();
365                match run_result {
366                    Some(run_result) => builder.append_n(run_end - run_start, run_result),
367                    None => builder.append_nulls(run_end - run_start),
368                }
369                run_start = run_end;
370            }
371            builder.finish()
372        },
373        _ => unreachable!("expected a run-end encoded array")
374    )
375}
376
377fn run_end_encoded_as_dictionary(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
378    downcast_run_array!(
379        array => run_array_as_dictionary(array),
380        _ => unreachable!("expected a run-end encoded array")
381    )
382}
383
384/// Views a run array as a dictionary whose keys are each row's index into [`run_values`].
385fn run_array_as_dictionary<R: RunEndIndexType + ArrowDictionaryKeyType>(
386    array: &RunArray<R>,
387) -> Result<ArrayRef, ArrowError> {
388    let mut keys = Vec::with_capacity(array.len());
389    let mut run_start = 0;
390    for (run_index, run_end) in array.run_ends().sliced_values().enumerate() {
391        let run_end = run_end.as_usize();
392        keys.extend(std::iter::repeat_n(
393            R::Native::usize_as(run_index),
394            run_end - run_start,
395        ));
396        run_start = run_end;
397    }
398    let keys = PrimitiveArray::<R>::new(keys.into(), None);
399    let values = array.values_slice();
400    if values.as_any_dictionary_opt().is_some() {
401        // Taking from a dictionary composes the keys, leaving a single dictionary
402        // layer for like_op to unwrap.
403        take(&values, &keys, None)
404    } else {
405        Ok(Arc::new(DictionaryArray::try_new(keys, values)?))
406    }
407}
408
409fn string_apply<'a, T: StringArrayType<'a> + 'a>(
410    op: Op,
411    l: T,
412    l_s: bool,
413    l_v: Option<&'a dyn AnyDictionaryArray>,
414    r: T,
415    r_s: bool,
416    r_v: Option<&'a dyn AnyDictionaryArray>,
417) -> Result<BooleanArray, ArrowError> {
418    let l_len = l_v.map_or_else(|| l.len(), |l| l.len());
419    // A valid dictionary without values can only contain null keys.
420    if l_v.is_some_and(|dict| dict.values().is_empty())
421        || r_v.is_some_and(|dict| dict.values().is_empty())
422    {
423        let len = if l_s {
424            r_v.map_or_else(|| r.len(), |r| r.len())
425        } else {
426            l_len
427        };
428        return Ok(BooleanArray::new_null(len));
429    }
430    if r_s {
431        let idx = match r_v {
432            Some(dict) if dict.null_count() != 0 => return Ok(BooleanArray::new_null(l_len)),
433            Some(dict) => dict.normalized_keys()[0],
434            None => 0,
435        };
436        if r.is_null(idx) {
437            return Ok(BooleanArray::new_null(l_len));
438        }
439        op_scalar::<T>(op, l, l_v, r.value(idx))
440    } else {
441        match (l_s, l_v, r_v) {
442            (true, None, None) => {
443                let v = l.is_valid(0).then(|| l.value(0));
444                op_binary(op, std::iter::repeat(v), r.iter())
445            }
446            (true, Some(l_v), None) => {
447                let idx = l_v.is_valid(0).then(|| l_v.normalized_keys()[0]);
448                let v = idx.and_then(|idx| l.is_valid(idx).then(|| l.value(idx)));
449                op_binary(op, std::iter::repeat(v), r.iter())
450            }
451            (true, None, Some(r_v)) => {
452                let v = l.is_valid(0).then(|| l.value(0));
453                op_binary(op, std::iter::repeat(v), vectored_iter(r, r_v))
454            }
455            (true, Some(l_v), Some(r_v)) => {
456                let idx = l_v.is_valid(0).then(|| l_v.normalized_keys()[0]);
457                let v = idx.and_then(|idx| l.is_valid(idx).then(|| l.value(idx)));
458                op_binary(op, std::iter::repeat(v), vectored_iter(r, r_v))
459            }
460            (false, None, None) => op_binary(op, l.iter(), r.iter()),
461            (false, Some(l_v), None) => op_binary(op, vectored_iter(l, l_v), r.iter()),
462            (false, None, Some(r_v)) => op_binary(op, l.iter(), vectored_iter(r, r_v)),
463            (false, Some(l_v), Some(r_v)) => {
464                op_binary(op, vectored_iter(l, l_v), vectored_iter(r, r_v))
465            }
466        }
467    }
468}
469
470#[inline(never)]
471fn op_scalar<'a, T: StringArrayType<'a>>(
472    op: Op,
473    l: T,
474    l_v: Option<&dyn AnyDictionaryArray>,
475    r: &str,
476) -> Result<BooleanArray, ArrowError> {
477    let r = match op {
478        Op::Like(neg) => Predicate::like(r)?.evaluate_array(l, neg),
479        Op::ILike(neg) => Predicate::ilike(r, l.is_ascii())?.evaluate_array(l, neg),
480        Op::Contains => Predicate::contains(r).evaluate_array(l, false),
481        Op::EqIgnoreAsciiCase => Predicate::IEqAscii(r).evaluate_array(l, false),
482        Op::StartsWith => Predicate::StartsWith(r).evaluate_array(l, false),
483        Op::EndsWith => Predicate::EndsWith(r).evaluate_array(l, false),
484    };
485
486    Ok(match l_v {
487        Some(v) => take(&r, v.keys(), None)?.as_boolean().clone(),
488        None => r,
489    })
490}
491
492fn vectored_iter<'a, T: StringArrayType<'a> + 'a>(
493    a: T,
494    a_v: &'a dyn AnyDictionaryArray,
495) -> impl Iterator<Item = Option<&'a str>> + 'a {
496    let nulls = a_v.nulls();
497    let keys = a_v.normalized_keys();
498    keys.into_iter().enumerate().map(move |(idx, key)| {
499        if nulls.is_some_and(|n| n.is_null(idx)) || a.is_null(key) {
500            return None;
501        }
502        Some(a.value(key))
503    })
504}
505
506#[inline(never)]
507fn op_binary<'a>(
508    op: Op,
509    l: impl Iterator<Item = Option<&'a str>>,
510    r: impl Iterator<Item = Option<&'a str>>,
511) -> Result<BooleanArray, ArrowError> {
512    match op {
513        Op::Like(neg) => binary_predicate(l, r, neg, Predicate::like),
514        Op::ILike(neg) => binary_predicate(l, r, neg, |s| Predicate::ilike(s, false)),
515        Op::Contains => Ok(l.zip(r).map(|(l, r)| Some(str_contains(l?, r?))).collect()),
516        Op::EqIgnoreAsciiCase => Ok(l
517            .zip(r)
518            .map(|(l, r)| Some(Predicate::IEqAscii(l?).evaluate(r?)))
519            .collect()),
520        Op::StartsWith => Ok(l
521            .zip(r)
522            .map(|(l, r)| Some(Predicate::StartsWith(r?).evaluate(l?)))
523            .collect()),
524        Op::EndsWith => Ok(l
525            .zip(r)
526            .map(|(l, r)| Some(Predicate::EndsWith(r?).evaluate(l?)))
527            .collect()),
528    }
529}
530
531fn str_contains(haystack: &str, needle: &str) -> bool {
532    memchr::memmem::find(haystack.as_bytes(), needle.as_bytes()).is_some()
533}
534
535fn binary_predicate<'a>(
536    l: impl Iterator<Item = Option<&'a str>>,
537    r: impl Iterator<Item = Option<&'a str>>,
538    neg: bool,
539    f: impl Fn(&'a str) -> Result<Predicate<'a>, ArrowError>,
540) -> Result<BooleanArray, ArrowError> {
541    let mut previous = None;
542    l.zip(r)
543        .map(|(l, r)| match (l, r) {
544            (Some(l), Some(r)) => {
545                let p: &Predicate = match previous {
546                    Some((expr, ref predicate)) if expr == r => predicate,
547                    _ => &previous.insert((r, f(r)?)).1,
548                };
549                Ok(Some(p.evaluate(l) != neg))
550            }
551            _ => Ok(None),
552        })
553        .collect()
554}
555
556#[cfg(test)]
557mod tests {
558    use super::*;
559    use arrow_array::builder::BinaryDictionaryBuilder;
560    use arrow_array::types::{ArrowDictionaryKeyType, Int8Type, Int32Type, Int64Type};
561    use std::iter::zip;
562
563    fn convert_binary_iterator_to_binary_dictionary<
564        'a,
565        K: ArrowDictionaryKeyType,
566        I: IntoIterator<Item = &'a [u8]>,
567    >(
568        iter: I,
569    ) -> DictionaryArray<K> {
570        let it = iter.into_iter();
571        let (lower, _) = it.size_hint();
572        let mut builder = BinaryDictionaryBuilder::with_capacity(lower, 256, 1024);
573        it.for_each(|i| {
574            builder
575                .append(i)
576                .expect("Unable to append a value to a dictionary array.");
577        });
578
579        builder.finish()
580    }
581
582    /// Applying `op(left, right)`, both sides are arrays
583    /// The macro tests five types of array implementations:
584    /// - `StringArray`
585    /// - `LargeStringArray`
586    /// - `StringViewArray`
587    /// - `DictionaryArray`
588    /// - `RunArray`
589    macro_rules! test_utf8 {
590        ($(#[$attr:meta])* $test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
591            $(#[$attr])*
592            #[test]
593            fn $test_name() {
594                let expected = BooleanArray::from($expected);
595
596                let left = StringArray::from($left);
597                let right = StringArray::from($right);
598                let res = $op(&left, &right).unwrap();
599                assert_eq!(res, expected);
600
601                let left = LargeStringArray::from($left);
602                let right = LargeStringArray::from($right);
603                let res = $op(&left, &right).unwrap();
604                assert_eq!(res, expected);
605
606                let left = StringViewArray::from($left);
607                let right = StringViewArray::from($right);
608                let res = $op(&left, &right).unwrap();
609                assert_eq!(res, expected);
610
611                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();
612                let right: DictionaryArray<Int8Type> = $right.into_iter().collect();
613                let res = $op(&left, &right).unwrap();
614                assert_eq!(res, expected);
615
616                let left: RunArray<Int32Type> = $left.into_iter().collect();
617                let right: RunArray<Int32Type> = $right.into_iter().collect();
618                let res = $op(&left, &right).unwrap();
619                assert_eq!(res, expected);
620            }
621        };
622    }
623
624    /// Applying `op(left, right)`, both sides are arrays
625    /// The macro tests five types of array implementations:
626    /// - `StringArray`
627    /// - `LargeStringArray`
628    /// - `StringViewArray`
629    /// - `DictionaryArray`
630    /// - `RunArray`
631    macro_rules! test_utf8_and_binary {
632        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
633            #[test]
634            fn $test_name() {
635                let expected = BooleanArray::from($expected);
636
637                let left = StringArray::from($left);
638                let right = StringArray::from($right);
639                let res = $op(&left, &right).unwrap();
640                assert_eq!(res, expected);
641
642                let left = LargeStringArray::from($left);
643                let right = LargeStringArray::from($right);
644                let res = $op(&left, &right).unwrap();
645                assert_eq!(res, expected);
646
647                let left = StringViewArray::from($left);
648                let right = StringViewArray::from($right);
649                let res = $op(&left, &right).unwrap();
650                assert_eq!(res, expected);
651
652                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();
653                let right: DictionaryArray<Int8Type> = $right.into_iter().collect();
654                let res = $op(&left, &right).unwrap();
655                assert_eq!(res, expected);
656
657                let left: RunArray<Int32Type> = $left.into_iter().collect();
658                let right: RunArray<Int32Type> = $right.into_iter().collect();
659                let res = $op(&left, &right).unwrap();
660                assert_eq!(res, expected);
661
662                let left_binary = $left.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();
663                let right_binary = $right.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();
664
665                let left = BinaryArray::from(left_binary.clone());
666                let right = BinaryArray::from(right_binary.clone());
667                let res = $op(&left, &right).unwrap();
668                assert_eq!(res, expected);
669
670                let left = LargeBinaryArray::from(left_binary.clone());
671                let right = LargeBinaryArray::from(right_binary.clone());
672                let res = $op(&left, &right).unwrap();
673                assert_eq!(res, expected);
674
675                let left: DictionaryArray<Int8Type> =
676                    convert_binary_iterator_to_binary_dictionary(left_binary);
677                let right: DictionaryArray<Int8Type> =
678                    convert_binary_iterator_to_binary_dictionary(right_binary);
679                let res = $op(&left, &right).unwrap();
680                assert_eq!(res, expected);
681            }
682        };
683    }
684
685    /// Applying `op(left, right)`, left side is array, right side is scalar
686    /// The macro tests five types of array implementations:
687    /// - `StringArray`
688    /// - `LargeStringArray`
689    /// - `StringViewArray`
690    /// - `DictionaryArray`
691    /// - `RunArray`
692    macro_rules! test_utf8_scalar {
693        ($(#[$attr:meta])* $test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
694            $(#[$attr])*
695            #[test]
696            fn $test_name() {
697                let expected = BooleanArray::from($expected);
698
699                let left = StringArray::from($left);
700                let right = StringArray::from_iter_values([$right]);
701                let res = $op(&left, &Scalar::new(&right)).unwrap();
702                assert_eq!(res, expected);
703
704                let left = LargeStringArray::from($left);
705                let right = LargeStringArray::from_iter_values([$right]);
706                let res = $op(&left, &Scalar::new(&right)).unwrap();
707                assert_eq!(res, expected);
708
709                let left = StringViewArray::from($left);
710                let right = StringViewArray::from_iter_values([$right]);
711                let res = $op(&left, &Scalar::new(&right)).unwrap();
712                assert_eq!(res, expected);
713
714                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();
715                let right = StringArray::from_iter_values([$right]);
716                let res = $op(&left, &Scalar::new(&right)).unwrap();
717                assert_eq!(res, expected);
718
719                let right: DictionaryArray<Int8Type> = [$right].into_iter().collect();
720                let res = $op(&left, &Scalar::new(&right)).unwrap();
721                assert_eq!(res, expected);
722
723                let left: RunArray<Int32Type> = $left.into_iter().collect();
724                let right: RunArray<Int32Type> = [$right].into_iter().collect();
725                let res = $op(&left, &Scalar::new(&right)).unwrap();
726                assert_eq!(res, expected);
727            }
728        };
729    }
730
731    /// Applying `op(left, right)`, left side is array, right side is scalar
732    /// The macro tests five types of array implementations:
733    /// - `StringArray`
734    /// - `LargeStringArray`
735    /// - `StringViewArray`
736    /// - `DictionaryArray`
737    /// - `RunArray`
738    macro_rules! test_utf8_and_binary_scalar {
739        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
740            #[test]
741            fn $test_name() {
742                let expected = BooleanArray::from($expected);
743
744                let left = StringArray::from($left);
745                let right = StringArray::from_iter_values([$right]);
746                let res = $op(&left, &Scalar::new(&right)).unwrap();
747                assert_eq!(res, expected);
748
749                let left = LargeStringArray::from($left);
750                let right = LargeStringArray::from_iter_values([$right]);
751                let res = $op(&left, &Scalar::new(&right)).unwrap();
752                assert_eq!(res, expected);
753
754                let left = StringViewArray::from($left);
755                let right = StringViewArray::from_iter_values([$right]);
756                let res = $op(&left, &Scalar::new(&right)).unwrap();
757                assert_eq!(res, expected);
758
759                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();
760                let right: DictionaryArray<Int8Type> = [$right].into_iter().collect();
761                let res = $op(&left, &Scalar::new(&right)).unwrap();
762                assert_eq!(res, expected);
763
764                let left: RunArray<Int32Type> = $left.into_iter().collect();
765                let right: RunArray<Int32Type> = [$right].into_iter().collect();
766                let res = $op(&left, &Scalar::new(&right)).unwrap();
767                assert_eq!(res, expected);
768
769                let left_binary = $left.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();
770                let right_binary: &[u8] = $right.as_ref();
771
772                let left = BinaryArray::from(left_binary.clone());
773                let right = BinaryArray::from_iter_values([right_binary]);
774                let res = $op(&left, &Scalar::new(&right)).unwrap();
775                assert_eq!(res, expected);
776
777                let left = LargeBinaryArray::from(left_binary.clone());
778                let right = LargeBinaryArray::from_iter_values([right_binary]);
779                let res = $op(&left, &Scalar::new(&right)).unwrap();
780                assert_eq!(res, expected);
781
782                let left: DictionaryArray<Int8Type> =
783                    convert_binary_iterator_to_binary_dictionary(left_binary);
784                let right: DictionaryArray<Int8Type> =
785                    convert_binary_iterator_to_binary_dictionary([right_binary]);
786                let res = $op(&left, &Scalar::new(&right)).unwrap();
787                assert_eq!(res, expected);
788            }
789        };
790    }
791
792    test_utf8!(
793        test_utf8_array_like,
794        vec![
795            "arrow",
796            "arrow_long_string_more than 12 bytes",
797            "arrow",
798            "arrow",
799            "arrow",
800            "arrows",
801            "arrow",
802            "arrow"
803        ],
804        vec![
805            "arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_", ".*"
806        ],
807        like,
808        vec![true, true, true, false, false, true, false, false]
809    );
810
811    test_utf8_scalar!(
812        #[cfg_attr(miri, ignore)] // Takes too long
813        test_utf8_array_like_scalar_escape_testing,
814        vec![
815            "varchar(255)",
816            "int(255)longer than 12 bytes",
817            "varchar",
818            "int"
819        ],
820        "%(%)%",
821        like,
822        vec![true, true, false, false]
823    );
824
825    test_utf8_scalar!(
826        test_utf8_array_like_scalar_escape_regex,
827        vec![".*", "a", "*"],
828        ".*",
829        like,
830        vec![true, false, false]
831    );
832
833    test_utf8_scalar!(
834        test_utf8_array_like_scalar_escape_regex_dot,
835        vec![".", "a", "*"],
836        ".",
837        like,
838        vec![true, false, false]
839    );
840
841    test_utf8_scalar!(
842        test_utf8_array_like_scalar,
843        vec![
844            "arrow",
845            "parquet",
846            "datafusion",
847            "flight",
848            "long string arrow test 12 bytes"
849        ],
850        "%ar%",
851        like,
852        vec![true, true, false, false, true]
853    );
854
855    test_utf8_scalar!(
856        test_utf8_array_like_scalar_start,
857        vec![
858            "arrow",
859            "parrow",
860            "arrows",
861            "arr",
862            "arrow long string longer than 12 bytes"
863        ],
864        "arrow%",
865        like,
866        vec![true, false, true, false, true]
867    );
868
869    // Replicates `test_utf8_array_like_scalar_start` `test_utf8_array_like_scalar_dyn_start` to
870    // demonstrate that `SQL STARTSWITH` works as expected.
871    test_utf8_and_binary_scalar!(
872        test_utf8_and_binary_array_starts_with_scalar_start,
873        vec![
874            "arrow",
875            "parrow",
876            "arrows",
877            "arr",
878            "arrow long string longer than 12 bytes"
879        ],
880        "arrow",
881        starts_with,
882        vec![true, false, true, false, true]
883    );
884
885    test_utf8_and_binary!(
886        test_utf8_and_binary_array_starts_with,
887        vec![
888            "arrow",
889            "arrow_long_string_more than 12 bytes",
890            "arrow",
891            "arrow",
892            "arrow",
893            "arrows",
894            "arrow",
895            "arrow"
896        ],
897        vec![
898            "arrow", "ar%", "row", "foo", "arr", "arrow_", "arrow_", ".*"
899        ],
900        starts_with,
901        vec![true, false, false, false, true, false, false, false]
902    );
903
904    test_utf8_scalar!(
905        test_utf8_array_like_scalar_end,
906        vec![
907            "arrow",
908            "parrow",
909            "arrows",
910            "arr",
911            "arrow long string longer than 12 bytes"
912        ],
913        "%arrow",
914        like,
915        vec![true, true, false, false, false]
916    );
917
918    // Replicates `test_utf8_array_like_scalar_end` `test_utf8_array_like_scalar_dyn_end` to
919    // demonstrate that `SQL ENDSWITH` works as expected.
920    test_utf8_and_binary_scalar!(
921        test_utf8_and_binary_array_ends_with_scalar_end,
922        vec![
923            "arrow",
924            "parrow",
925            "arrows",
926            "arr",
927            "arrow long string longer than 12 bytes"
928        ],
929        "arrow",
930        ends_with,
931        vec![true, true, false, false, false]
932    );
933
934    test_utf8_and_binary!(
935        test_utf8_and_binary_array_ends_with,
936        vec![
937            "arrow",
938            "arrow_long_string_more than 12 bytes",
939            "arrow",
940            "arrow",
941            "arrow",
942            "arrows",
943            "arrow",
944            "arrow"
945        ],
946        vec![
947            "arrow", "ar%", "row", "foo", "arr", "arrow_", "arrow_", ".*"
948        ],
949        ends_with,
950        vec![true, false, true, false, false, false, false, false]
951    );
952
953    test_utf8_scalar!(
954        test_utf8_array_like_scalar_equals,
955        vec![
956            "arrow",
957            "parrow",
958            "arrows",
959            "arr",
960            "arrow long string longer than 12 bytes"
961        ],
962        "arrow",
963        like,
964        vec![true, false, false, false, false]
965    );
966
967    test_utf8_scalar!(
968        #[cfg_attr(miri, ignore)] // Takes too long
969        test_utf8_array_like_scalar_one,
970        vec![
971            "arrow",
972            "arrows",
973            "parrow",
974            "arr",
975            "arrow long string longer than 12 bytes"
976        ],
977        "arrow_",
978        like,
979        vec![false, true, false, false, false]
980    );
981
982    test_utf8_scalar!(
983        test_utf8_scalar_like_escape,
984        vec!["a%", "a\\x", "arrow long string longer than 12 bytes"],
985        "a\\%",
986        like,
987        vec![true, false, false]
988    );
989
990    test_utf8_scalar!(
991        test_utf8_scalar_like_escape_contains,
992        vec!["ba%", "ba\\x", "arrow long string longer than 12 bytes"],
993        "%a\\%",
994        like,
995        vec![true, false, false]
996    );
997
998    test_utf8!(
999        test_utf8_scalar_ilike_regex,
1000        vec!["%%%"],
1001        vec![r"\%_\%"],
1002        ilike,
1003        vec![true]
1004    );
1005
1006    test_utf8!(
1007        test_utf8_array_nlike,
1008        vec![
1009            "arrow",
1010            "arrow",
1011            "arrow long string longer than 12 bytes",
1012            "arrow",
1013            "arrow",
1014            "arrows",
1015            "arrow"
1016        ],
1017        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_"],
1018        nlike,
1019        vec![false, false, false, true, true, false, true]
1020    );
1021
1022    test_utf8_scalar!(
1023        #[cfg_attr(miri, ignore)] // Takes too long
1024        test_utf8_array_nlike_escape_testing,
1025        vec![
1026            "varchar(255)",
1027            "int(255) arrow long string longer than 12 bytes",
1028            "varchar",
1029            "int"
1030        ],
1031        "%(%)%",
1032        nlike,
1033        vec![false, false, true, true]
1034    );
1035
1036    test_utf8_scalar!(
1037        test_utf8_array_nlike_scalar_escape_regex,
1038        vec![".*", "a", "*"],
1039        ".*",
1040        nlike,
1041        vec![false, true, true]
1042    );
1043
1044    test_utf8_scalar!(
1045        test_utf8_array_nlike_scalar_escape_regex_dot,
1046        vec![".", "a", "*"],
1047        ".",
1048        nlike,
1049        vec![false, true, true]
1050    );
1051    test_utf8_scalar!(
1052        test_utf8_array_nlike_scalar,
1053        vec![
1054            "arrow",
1055            "parquet",
1056            "datafusion",
1057            "flight",
1058            "arrow long string longer than 12 bytes"
1059        ],
1060        "%ar%",
1061        nlike,
1062        vec![false, false, true, true, false]
1063    );
1064
1065    test_utf8_scalar!(
1066        test_utf8_array_nlike_scalar_start,
1067        vec![
1068            "arrow",
1069            "parrow",
1070            "arrows",
1071            "arr",
1072            "arrow long string longer than 12 bytes"
1073        ],
1074        "arrow%",
1075        nlike,
1076        vec![false, true, false, true, false]
1077    );
1078
1079    test_utf8_scalar!(
1080        test_utf8_array_nlike_scalar_end,
1081        vec![
1082            "arrow",
1083            "parrow",
1084            "arrows",
1085            "arr",
1086            "arrow long string longer than 12 bytes"
1087        ],
1088        "%arrow",
1089        nlike,
1090        vec![false, false, true, true, true]
1091    );
1092
1093    test_utf8_scalar!(
1094        test_utf8_array_nlike_scalar_equals,
1095        vec![
1096            "arrow",
1097            "parrow",
1098            "arrows",
1099            "arr",
1100            "arrow long string longer than 12 bytes"
1101        ],
1102        "arrow",
1103        nlike,
1104        vec![false, true, true, true, true]
1105    );
1106
1107    test_utf8_scalar!(
1108        #[cfg_attr(miri, ignore)] // Takes too long
1109        test_utf8_array_nlike_scalar_one,
1110        vec![
1111            "arrow",
1112            "arrows",
1113            "parrow",
1114            "arr",
1115            "arrow long string longer than 12 bytes"
1116        ],
1117        "arrow_",
1118        nlike,
1119        vec![true, false, true, true, true]
1120    );
1121
1122    test_utf8!(
1123        #[cfg_attr(miri, ignore)] // Takes too long
1124        test_utf8_array_ilike,
1125        vec![
1126            "arrow",
1127            "arrow",
1128            "ARROW long string longer than 12 bytes",
1129            "arrow",
1130            "ARROW",
1131            "ARROWS",
1132            "arROw"
1133        ],
1134        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
1135        ilike,
1136        vec![true, true, true, false, false, true, false]
1137    );
1138
1139    test_utf8_scalar!(
1140        #[cfg_attr(miri, ignore)] // Takes too long
1141        ilike_utf8_scalar_escape_testing,
1142        vec![
1143            "varchar(255)",
1144            "int(255) long string longer than 12 bytes",
1145            "varchar",
1146            "int"
1147        ],
1148        "%(%)%",
1149        ilike,
1150        vec![true, true, false, false]
1151    );
1152
1153    test_utf8_scalar!(
1154        test_utf8_array_ilike_scalar,
1155        vec![
1156            "arrow",
1157            "parquet",
1158            "datafusion",
1159            "flight",
1160            "arrow long string longer than 12 bytes"
1161        ],
1162        "%AR%",
1163        ilike,
1164        vec![true, true, false, false, true]
1165    );
1166
1167    test_utf8_scalar!(
1168        test_utf8_array_ilike_scalar_start,
1169        vec![
1170            "arrow",
1171            "parrow",
1172            "arrows",
1173            "ARR",
1174            "arrow long string longer than 12 bytes"
1175        ],
1176        "aRRow%",
1177        ilike,
1178        vec![true, false, true, false, true]
1179    );
1180
1181    test_utf8_scalar!(
1182        test_utf8_array_ilike_scalar_end,
1183        vec![
1184            "ArroW",
1185            "parrow",
1186            "ARRowS",
1187            "arr",
1188            "arrow long string longer than 12 bytes"
1189        ],
1190        "%arrow",
1191        ilike,
1192        vec![true, true, false, false, false]
1193    );
1194
1195    test_utf8_scalar!(
1196        test_utf8_array_ilike_scalar_equals,
1197        vec![
1198            "arrow",
1199            "parrow",
1200            "arrows",
1201            "arr",
1202            "arrow long string longer than 12 bytes"
1203        ],
1204        "Arrow",
1205        ilike,
1206        vec![true, false, false, false, false]
1207    );
1208
1209    // We only implement loose matching
1210    test_utf8_scalar!(
1211        #[cfg_attr(miri, ignore)] // Takes too long
1212        test_utf8_array_ilike_unicode,
1213        vec![
1214            "FFkoß",
1215            "FFkoSS",
1216            "FFkoss",
1217            "FFkoS",
1218            "FFkos",
1219            "ffkoSS",
1220            "ffkoß",
1221            "FFKoSS",
1222            "longer than 12 bytes FFKoSS"
1223        ],
1224        "FFkoSS",
1225        ilike,
1226        vec![false, true, true, false, false, false, false, true, false]
1227    );
1228
1229    test_utf8_scalar!(
1230        #[cfg_attr(miri, ignore)] // Takes too long
1231        test_utf8_array_ilike_unicode_starts,
1232        vec![
1233            "FFkoßsdlkdf",
1234            "FFkoSSsdlkdf",
1235            "FFkosssdlkdf",
1236            "FFkoS",
1237            "FFkos",
1238            "ffkoSS",
1239            "ffkoß",
1240            "FfkosSsdfd",
1241            "FFKoSS",
1242            "longer than 12 bytes FFKoSS",
1243        ],
1244        "FFkoSS%",
1245        ilike,
1246        vec![
1247            false, true, true, false, false, false, false, true, true, false
1248        ]
1249    );
1250
1251    test_utf8_scalar!(
1252        #[cfg_attr(miri, ignore)] // Takes too long
1253        test_utf8_array_ilike_unicode_ends,
1254        vec![
1255            "sdlkdfFFkoß",
1256            "sdlkdfFFkoSS",
1257            "sdlkdfFFkoss",
1258            "FFkoS",
1259            "FFkos",
1260            "ffkoSS",
1261            "ffkoß",
1262            "h😃klFfkosS",
1263            "FFKoSS",
1264            "longer than 12 bytes FFKoSS",
1265        ],
1266        "%FFkoSS",
1267        ilike,
1268        vec![
1269            false, true, true, false, false, false, false, true, true, true
1270        ]
1271    );
1272
1273    test_utf8_scalar!(
1274        #[cfg_attr(miri, ignore)] // Takes too long
1275        test_utf8_array_ilike_unicode_contains,
1276        vec![
1277            "sdlkdfFkoßsdfs",
1278            "sdlkdfFkoSSdggs",
1279            "sdlkdfFkosssdsd",
1280            "FkoS",
1281            "Fkos",
1282            "ffkoSS",
1283            "ffkoß",
1284            "😃sadlksffkosSsh😃klF",
1285            "😱slgffkosSsh😃klF",
1286            "FFKoSS",
1287            "longer than 12 bytes FFKoSS",
1288        ],
1289        "%FFkoSS%",
1290        ilike,
1291        vec![
1292            false, true, true, false, false, false, false, true, true, true, true
1293        ]
1294    );
1295
1296    // Replicates `test_utf8_array_ilike_unicode_contains` and
1297    // `test_utf8_array_ilike_unicode_contains_dyn` to
1298    // demonstrate that `SQL CONTAINS` works as expected.
1299    //
1300    // NOTE: 5 of the values were changed because the original used a case insensitive `ilike`.
1301    test_utf8_and_binary_scalar!(
1302        test_utf8_and_binary_array_contains_unicode_contains,
1303        vec![
1304            "sdlkdfFkoßsdfs",
1305            "sdlkdFFkoSSdggs", // Original was case insensitive "sdlkdfFkoSSdggs"
1306            "sdlkdFFkoSSsdsd", // Original was case insensitive "sdlkdfFkosssdsd"
1307            "FkoS",
1308            "Fkos",
1309            "ffkoSS",
1310            "ffkoß",
1311            "😃sadlksFFkoSSsh😃klF", // Original was case insensitive "😃sadlksffkosSsh😃klF"
1312            "😱slgFFkoSSsh😃klF",    // Original was case insensitive "😱slgffkosSsh😃klF"
1313            "FFkoSS",                // "FFKoSS"
1314            "longer than 12 bytes FFKoSS",
1315        ],
1316        "FFkoSS",
1317        contains,
1318        vec![
1319            false, true, true, false, false, false, false, true, true, true, false
1320        ]
1321    );
1322
1323    test_utf8_scalar!(
1324        #[cfg_attr(miri, ignore)] // Takes too long
1325        test_utf8_array_ilike_unicode_complex,
1326        vec![
1327            "sdlkdfFooßsdfs",
1328            "sdlkdfFooSSdggs",
1329            "sdlkdfFoosssdsd",
1330            "FooS",
1331            "Foos",
1332            "ffooSS",
1333            "ffooß",
1334            "😃sadlksffofsSsh😃klF",
1335            "😱slgffoesSsh😃klF",
1336            "FFKoSS",
1337            "longer than 12 bytes FFKoSS",
1338        ],
1339        "%FF__SS%",
1340        ilike,
1341        vec![
1342            false, true, true, false, false, false, false, true, true, true, true
1343        ]
1344    );
1345
1346    // 😈 is four bytes long.
1347    test_utf8_scalar!(
1348        test_uff8_array_like_multibyte,
1349        vec![
1350            "sdlkdfFooßsdfs",
1351            "sdlkdfFooSSdggs",
1352            "sdlkdfFoosssdsd",
1353            "FooS",
1354            "Foos",
1355            "ffooSS",
1356            "ffooß",
1357            "😃sadlksffofsSsh😈klF",
1358            "😱slgffoesSsh😈klF",
1359            "FFKoSS",
1360            "longer than 12 bytes FFKoSS",
1361        ],
1362        "%Ssh😈klF",
1363        like,
1364        vec![
1365            false, false, false, false, false, false, false, true, true, false, false
1366        ]
1367    );
1368
1369    test_utf8_scalar!(
1370        #[cfg_attr(miri, ignore)] // Takes too long
1371        test_utf8_array_ilike_scalar_one,
1372        vec![
1373            "arrow",
1374            "arrows",
1375            "parrow",
1376            "arr",
1377            "arrow long string longer than 12 bytes"
1378        ],
1379        "arrow_",
1380        ilike,
1381        vec![false, true, false, false, false]
1382    );
1383
1384    test_utf8!(
1385        #[cfg_attr(miri, ignore)] // Takes too long
1386        test_utf8_array_nilike,
1387        vec![
1388            "arrow",
1389            "arrow",
1390            "ARROW longer than 12 bytes string",
1391            "arrow",
1392            "ARROW",
1393            "ARROWS",
1394            "arROw"
1395        ],
1396        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
1397        nilike,
1398        vec![false, false, false, true, true, false, true]
1399    );
1400
1401    test_utf8_scalar!(
1402        #[cfg_attr(miri, ignore)] // Takes too long
1403        nilike_utf8_scalar_escape_testing,
1404        vec![
1405            "varchar(255)",
1406            "int(255) longer than 12 bytes string",
1407            "varchar",
1408            "int"
1409        ],
1410        "%(%)%",
1411        nilike,
1412        vec![false, false, true, true]
1413    );
1414
1415    test_utf8_scalar!(
1416        test_utf8_array_nilike_scalar,
1417        vec![
1418            "arrow",
1419            "parquet",
1420            "datafusion",
1421            "flight",
1422            "arrow long string longer than 12 bytes"
1423        ],
1424        "%AR%",
1425        nilike,
1426        vec![false, false, true, true, false]
1427    );
1428
1429    test_utf8_scalar!(
1430        test_utf8_array_nilike_scalar_start,
1431        vec![
1432            "arrow",
1433            "parrow",
1434            "arrows",
1435            "ARR",
1436            "arrow long string longer than 12 bytes"
1437        ],
1438        "aRRow%",
1439        nilike,
1440        vec![false, true, false, true, false]
1441    );
1442
1443    test_utf8_scalar!(
1444        test_utf8_array_nilike_scalar_end,
1445        vec![
1446            "ArroW",
1447            "parrow",
1448            "ARRowS",
1449            "arr",
1450            "arrow long string longer than 12 bytes"
1451        ],
1452        "%arrow",
1453        nilike,
1454        vec![false, false, true, true, true]
1455    );
1456
1457    test_utf8_scalar!(
1458        test_utf8_array_nilike_scalar_equals,
1459        vec![
1460            "arRow",
1461            "parrow",
1462            "arrows",
1463            "arr",
1464            "arrow long string longer than 12 bytes"
1465        ],
1466        "Arrow",
1467        nilike,
1468        vec![false, true, true, true, true]
1469    );
1470
1471    test_utf8_scalar!(
1472        #[cfg_attr(miri, ignore)] // Takes too long
1473        test_utf8_array_nilike_scalar_one,
1474        vec![
1475            "arrow",
1476            "arrows",
1477            "parrow",
1478            "arr",
1479            "arrow long string longer than 12 bytes"
1480        ],
1481        "arrow_",
1482        nilike,
1483        vec![true, false, true, true, true]
1484    );
1485
1486    // Nullable, repeated values exercise dictionary remapping with a plain UTF8 scalar RHS.
1487    test_utf8_scalar!(
1488        test_utf8_scalar_nullable_like,
1489        vec![
1490            Some("Earth"),
1491            Some("Fire"),
1492            Some("Water"),
1493            Some("Air"),
1494            None,
1495            Some("Air"),
1496            Some("bbbbb\nAir")
1497        ],
1498        "Air",
1499        like,
1500        vec![
1501            Some(false),
1502            Some(false),
1503            Some(false),
1504            Some(true),
1505            None,
1506            Some(true),
1507            Some(false)
1508        ]
1509    );
1510
1511    test_utf8_scalar!(
1512        #[cfg_attr(miri, ignore)] // Takes too long
1513        test_utf8_scalar_nullable_nlike,
1514        vec![
1515            Some("Earth"),
1516            Some("Fire"),
1517            Some("Water"),
1518            Some("Air"),
1519            None,
1520            Some("Air"),
1521            Some("bbbbb\nAir")
1522        ],
1523        "%a%r%",
1524        nlike,
1525        vec![
1526            Some(false),
1527            Some(true),
1528            Some(false),
1529            Some(true),
1530            None,
1531            Some(true),
1532            Some(true)
1533        ]
1534    );
1535
1536    test_utf8_scalar!(
1537        test_utf8_scalar_nullable_ilike,
1538        vec![
1539            Some("Earth"),
1540            Some("Fire"),
1541            Some("Water"),
1542            Some("Air"),
1543            None,
1544            Some("Air"),
1545            Some("bbbbb\nAir")
1546        ],
1547        "%I%",
1548        ilike,
1549        vec![
1550            Some(false),
1551            Some(true),
1552            Some(false),
1553            Some(true),
1554            None,
1555            Some(true),
1556            Some(true)
1557        ]
1558    );
1559
1560    test_utf8_scalar!(
1561        test_utf8_scalar_nullable_nilike,
1562        vec![
1563            Some("Earth"),
1564            Some("Fire"),
1565            Some("Water"),
1566            Some("Air"),
1567            None,
1568            Some("Air"),
1569            Some("bbbbb\nAir")
1570        ],
1571        "%R",
1572        nilike,
1573        vec![
1574            Some(true),
1575            Some(true),
1576            Some(false),
1577            Some(false),
1578            None,
1579            Some(false),
1580            Some(false)
1581        ]
1582    );
1583
1584    #[test]
1585    #[cfg_attr(miri, ignore)] // Takes too long
1586    fn string_null_like_pattern() {
1587        // Different patterns have different execution code paths
1588        for pattern in &[
1589            "",           // can execute as equality check
1590            "_",          // can execute as length check
1591            "%",          // can execute as starts_with("") or non-null check
1592            "a%",         // can execute as starts_with("a")
1593            "%a",         // can execute as ends_with("")
1594            "a%b",        // can execute as starts_with("a") && ends_with("b")
1595            "%a%",        // can_execute as contains("a")
1596            "%a%b_c_d%e", // can_execute as regular expression
1597        ] {
1598            // These tests focus on the null handling, but are case-insensitive
1599            for like_f in [like, ilike, nlike, nilike] {
1600                let a = Scalar::new(StringArray::new_null(1));
1601                let b = StringArray::new_scalar(pattern);
1602                let r = like_f(&a, &b).unwrap();
1603                assert_eq!(r.len(), 1, "With pattern {pattern}");
1604                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1605                assert!(r.is_null(0), "With pattern {pattern}");
1606
1607                let a = Scalar::new(StringArray::new_null(1));
1608                let b = StringArray::from_iter_values([pattern]);
1609                let r = like_f(&a, &b).unwrap();
1610                assert_eq!(r.len(), 1, "With pattern {pattern}");
1611                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1612                assert!(r.is_null(0), "With pattern {pattern}");
1613
1614                let a = StringArray::new_null(1);
1615                let b = StringArray::from_iter_values([pattern]);
1616                let r = like_f(&a, &b).unwrap();
1617                assert_eq!(r.len(), 1, "With pattern {pattern}");
1618                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1619                assert!(r.is_null(0), "With pattern {pattern}");
1620
1621                let a = StringArray::new_null(1);
1622                let b = StringArray::new_scalar(pattern);
1623                let r = like_f(&a, &b).unwrap();
1624                assert_eq!(r.len(), 1, "With pattern {pattern}");
1625                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1626                assert!(r.is_null(0), "With pattern {pattern}");
1627            }
1628        }
1629    }
1630
1631    #[test]
1632    #[cfg_attr(miri, ignore)] // Takes too long
1633    fn string_view_null_like_pattern() {
1634        // Different patterns have different execution code paths
1635        for pattern in &[
1636            "",           // can execute as equality check
1637            "_",          // can execute as length check
1638            "%",          // can execute as starts_with("") or non-null check
1639            "a%",         // can execute as starts_with("a")
1640            "%a",         // can execute as ends_with("")
1641            "a%b",        // can execute as starts_with("a") && ends_with("b")
1642            "%a%",        // can_execute as contains("a")
1643            "%a%b_c_d%e", // can_execute as regular expression
1644        ] {
1645            // These tests focus on the null handling, but are case-insensitive
1646            for like_f in [like, ilike, nlike, nilike] {
1647                let a = Scalar::new(StringViewArray::new_null(1));
1648                let b = StringViewArray::new_scalar(pattern);
1649                let r = like_f(&a, &b).unwrap();
1650                assert_eq!(r.len(), 1, "With pattern {pattern}");
1651                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1652                assert!(r.is_null(0), "With pattern {pattern}");
1653
1654                let a = Scalar::new(StringViewArray::new_null(1));
1655                let b = StringViewArray::from_iter_values([pattern]);
1656                let r = like_f(&a, &b).unwrap();
1657                assert_eq!(r.len(), 1, "With pattern {pattern}");
1658                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1659                assert!(r.is_null(0), "With pattern {pattern}");
1660
1661                let a = StringViewArray::new_null(1);
1662                let b = StringViewArray::from_iter_values([pattern]);
1663                let r = like_f(&a, &b).unwrap();
1664                assert_eq!(r.len(), 1, "With pattern {pattern}");
1665                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1666                assert!(r.is_null(0), "With pattern {pattern}");
1667
1668                let a = StringViewArray::new_null(1);
1669                let b = StringViewArray::new_scalar(pattern);
1670                let r = like_f(&a, &b).unwrap();
1671                assert_eq!(r.len(), 1, "With pattern {pattern}");
1672                assert_eq!(r.null_count(), 1, "With pattern {pattern}");
1673                assert!(r.is_null(0), "With pattern {pattern}");
1674            }
1675        }
1676    }
1677
1678    #[test]
1679    fn string_like_scalar_null() {
1680        for like_f in [like, ilike, nlike, nilike] {
1681            let a = StringArray::new_scalar("a");
1682            let b = Scalar::new(StringArray::new_null(1));
1683            let r = like_f(&a, &b).unwrap();
1684            assert_eq!(r.len(), 1);
1685            assert_eq!(r.null_count(), 1);
1686            assert!(r.is_null(0));
1687
1688            let a = StringArray::from_iter_values(["a"]);
1689            let b = Scalar::new(StringArray::new_null(1));
1690            let r = like_f(&a, &b).unwrap();
1691            assert_eq!(r.len(), 1);
1692            assert_eq!(r.null_count(), 1);
1693            assert!(r.is_null(0));
1694
1695            let a = StringArray::from_iter_values(["a"]);
1696            let b = StringArray::new_null(1);
1697            let r = like_f(&a, &b).unwrap();
1698            assert_eq!(r.len(), 1);
1699            assert_eq!(r.null_count(), 1);
1700            assert!(r.is_null(0));
1701
1702            let a = StringArray::new_scalar("a");
1703            let b = StringArray::new_null(1);
1704            let r = like_f(&a, &b).unwrap();
1705            assert_eq!(r.len(), 1);
1706            assert_eq!(r.null_count(), 1);
1707            assert!(r.is_null(0));
1708        }
1709    }
1710
1711    #[test]
1712    fn string_view_like_scalar_null() {
1713        for like_f in [like, ilike, nlike, nilike] {
1714            let a = StringViewArray::new_scalar("a");
1715            let b = Scalar::new(StringViewArray::new_null(1));
1716            let r = like_f(&a, &b).unwrap();
1717            assert_eq!(r.len(), 1);
1718            assert_eq!(r.null_count(), 1);
1719            assert!(r.is_null(0));
1720
1721            let a = StringViewArray::from_iter_values(["a"]);
1722            let b = Scalar::new(StringViewArray::new_null(1));
1723            let r = like_f(&a, &b).unwrap();
1724            assert_eq!(r.len(), 1);
1725            assert_eq!(r.null_count(), 1);
1726            assert!(r.is_null(0));
1727
1728            let a = StringViewArray::from_iter_values(["a"]);
1729            let b = StringViewArray::new_null(1);
1730            let r = like_f(&a, &b).unwrap();
1731            assert_eq!(r.len(), 1);
1732            assert_eq!(r.null_count(), 1);
1733            assert!(r.is_null(0));
1734
1735            let a = StringViewArray::new_scalar("a");
1736            let b = StringViewArray::new_null(1);
1737            let r = like_f(&a, &b).unwrap();
1738            assert_eq!(r.len(), 1);
1739            assert_eq!(r.null_count(), 1);
1740            assert!(r.is_null(0));
1741        }
1742    }
1743
1744    #[test]
1745    fn test_utf8_dictionary_empty_values() {
1746        let dictionary = DictionaryArray::<Int8Type>::try_new(
1747            Int8Array::from(vec![None, None]),
1748            Arc::new(StringArray::from(Vec::<&str>::new())),
1749        )
1750        .unwrap();
1751        let patterns = StringArray::from(vec!["a%", "b%"]);
1752
1753        assert_eq!(
1754            like(&dictionary, &patterns).unwrap(),
1755            BooleanArray::new_null(2)
1756        );
1757        assert_eq!(
1758            like(&patterns, &dictionary).unwrap(),
1759            BooleanArray::new_null(2)
1760        );
1761
1762        let scalar_dictionary = DictionaryArray::<Int8Type>::try_new(
1763            Int8Array::from(vec![None]),
1764            Arc::new(StringArray::from(Vec::<&str>::new())),
1765        )
1766        .unwrap();
1767        assert_eq!(
1768            like(&Scalar::new(&scalar_dictionary), &patterns).unwrap(),
1769            BooleanArray::new_null(2)
1770        );
1771        assert_eq!(
1772            like(&patterns, &Scalar::new(&scalar_dictionary)).unwrap(),
1773            BooleanArray::new_null(2)
1774        );
1775
1776        let empty_dictionary = DictionaryArray::<Int8Type>::try_new(
1777            Int8Array::from(Vec::<Option<i8>>::new()),
1778            Arc::new(StringArray::from(Vec::<&str>::new())),
1779        )
1780        .unwrap();
1781        assert_eq!(
1782            like(&empty_dictionary, &StringArray::from(Vec::<&str>::new())).unwrap(),
1783            BooleanArray::new_null(0)
1784        );
1785    }
1786
1787    #[test]
1788    fn test_binary_dictionary_empty_values() {
1789        let dictionary = DictionaryArray::<Int8Type>::try_new(
1790            Int8Array::from(vec![None, None]),
1791            Arc::new(BinaryArray::from(Vec::<&[u8]>::new())),
1792        )
1793        .unwrap();
1794        let patterns = BinaryArray::from(vec![b"a".as_slice(), b"b".as_slice()]);
1795
1796        assert_eq!(
1797            starts_with(&dictionary, &patterns).unwrap(),
1798            BooleanArray::new_null(2)
1799        );
1800        assert_eq!(
1801            starts_with(&patterns, &dictionary).unwrap(),
1802            BooleanArray::new_null(2)
1803        );
1804    }
1805
1806    #[test]
1807    fn test_run_end_encoded_sliced() {
1808        // Logical rows after the slice: ["arrow", null, null, "Parquet", "Parquet"].
1809        // The slice starts and ends mid-run and skips the first run entirely.
1810        let run_ends = Int32Array::from(vec![2, 4, 6, 9]);
1811        let values = vec![Some("skipped"), Some("arrow"), None, Some("Parquet")];
1812        let dictionary: DictionaryArray<Int8Type> = values.clone().into_iter().collect();
1813        let patterns =
1814            StringArray::from(vec![Some("%row"), Some("%"), None, Some("P%"), Some("p%")]);
1815
1816        for run_values in [&StringArray::from(values) as &dyn Array, &dictionary] {
1817            let run = RunArray::<Int32Type>::try_new(&run_ends, run_values)
1818                .unwrap()
1819                .slice(3, 5);
1820
1821            let res = ilike(&run, &StringArray::new_scalar("a%")).unwrap();
1822            assert_eq!(
1823                res,
1824                BooleanArray::from(vec![Some(true), None, None, Some(false), Some(false)])
1825            );
1826
1827            let res = eq_ignore_ascii_case(&run, &StringArray::new_scalar("ARROW")).unwrap();
1828            assert_eq!(
1829                res,
1830                BooleanArray::from(vec![Some(true), None, None, Some(false), Some(false)])
1831            );
1832
1833            let res = like(&run, &patterns).unwrap();
1834            assert_eq!(
1835                res,
1836                BooleanArray::from(vec![Some(true), None, None, Some(true), Some(false)])
1837            );
1838
1839            let res = like(&Scalar::new(run.slice(0, 1)), &patterns).unwrap();
1840            assert_eq!(
1841                res,
1842                BooleanArray::from(vec![Some(true), Some(true), None, Some(false), Some(false)])
1843            );
1844
1845            let res = like(&run, &Scalar::new(StringArray::new_null(1))).unwrap();
1846            assert_eq!(res, BooleanArray::new_null(5));
1847
1848            let empty = run.slice(0, 0);
1849            let res = like(&empty, &StringArray::new_scalar("a%")).unwrap();
1850            assert_eq!(res, BooleanArray::from(Vec::<bool>::new()));
1851            let res = like(&empty, &patterns.slice(0, 0)).unwrap();
1852            assert_eq!(res, BooleanArray::from(Vec::<bool>::new()));
1853        }
1854    }
1855
1856    #[test]
1857    fn test_run_end_encoded_patterns() {
1858        // Logical patterns: ["arr%", "arr%", null, "%row", "x%"].
1859        let patterns = RunArray::<Int64Type>::try_new(
1860            &Int64Array::from(vec![2, 3, 4, 5]),
1861            &StringArray::from(vec![Some("arr%"), None, Some("%row"), Some("x%")]),
1862        )
1863        .unwrap();
1864
1865        let res = like(&StringArray::new_scalar("arrow"), &patterns).unwrap();
1866        assert_eq!(
1867            res,
1868            BooleanArray::from(vec![Some(true), Some(true), None, Some(true), Some(false)])
1869        );
1870
1871        let values = StringArray::from(vec!["arrow", "parquet", "arrow", "narrow", "xyz"]);
1872        let res = like(&values, &patterns).unwrap();
1873        assert_eq!(
1874            res,
1875            BooleanArray::from(vec![Some(true), Some(false), None, Some(true), Some(true)])
1876        );
1877    }
1878
1879    #[test]
1880    fn test_run_end_encoded_type_mismatch() {
1881        let run: RunArray<Int32Type> = std::iter::once("arrow").collect();
1882        let err = like(&run, &LargeStringArray::new_scalar("a%")).unwrap_err();
1883        assert_eq!(
1884            err.to_string(),
1885            "Invalid argument error: Invalid string/binary operation: Utf8 LIKE LargeUtf8"
1886        );
1887
1888        let empty: RunArray<Int32Type> = std::iter::empty::<&str>().collect();
1889        let err = like(&empty, &Int32Array::from(Vec::<i32>::new())).unwrap_err();
1890        assert_eq!(
1891            err.to_string(),
1892            "Invalid argument error: Invalid string/binary operation: Utf8 LIKE Int32"
1893        );
1894        let err = like(&Int32Array::from(Vec::<i32>::new()), &empty).unwrap_err();
1895        assert_eq!(
1896            err.to_string(),
1897            "Invalid argument error: Invalid string/binary operation: Int32 LIKE Utf8"
1898        );
1899    }
1900
1901    #[test]
1902    fn test_run_end_encoded_binary() {
1903        let values = BinaryArray::from(vec![b"arrow".as_slice(), b"parquet"]);
1904        let run = RunArray::<Int32Type>::try_new(&Int32Array::from(vec![2, 3]), &values).unwrap();
1905        let res = starts_with(&run, &BinaryArray::new_scalar(b"arr")).unwrap();
1906        assert_eq!(res, BooleanArray::from(vec![true, true, false]));
1907
1908        let patterns = BinaryArray::from(vec![b"arrow".as_slice(), b"x", b"et"]);
1909        let res = ends_with(&run, &patterns).unwrap();
1910        assert_eq!(res, BooleanArray::from(vec![true, false, true]));
1911    }
1912
1913    #[test]
1914    #[cfg_attr(miri, ignore)] // Takes too long
1915    fn like_escape() {
1916        // (value, pattern, expected)
1917        let test_cases = vec![
1918            // Empty pattern
1919            (r"", r"", true),
1920            (r"\", r"", false),
1921            // Sole (dangling) escape (some engines consider this invalid pattern)
1922            (r"", r"\", false),
1923            (r"\", r"\", true),
1924            (r"\\", r"\", false),
1925            (r"a", r"\", false),
1926            (r"\a", r"\", false),
1927            (r"\\a", r"\", false),
1928            // Sole escape
1929            (r"", r"\\", false),
1930            (r"\", r"\\", true),
1931            (r"\\", r"\\", false),
1932            (r"a", r"\\", false),
1933            (r"\a", r"\\", false),
1934            (r"\\a", r"\\", false),
1935            // Sole escape and dangling escape
1936            (r"", r"\\\", false),
1937            (r"\", r"\\\", false),
1938            (r"\\", r"\\\", true),
1939            (r"\\\", r"\\\", false),
1940            (r"\\\\", r"\\\", false),
1941            (r"a", r"\\\", false),
1942            (r"\a", r"\\\", false),
1943            (r"\\a", r"\\\", false),
1944            // Sole two escapes
1945            (r"", r"\\\\", false),
1946            (r"\", r"\\\\", false),
1947            (r"\\", r"\\\\", true),
1948            (r"\\\", r"\\\\", false),
1949            (r"\\\\", r"\\\\", false),
1950            (r"\\\\\", r"\\\\", false),
1951            (r"a", r"\\\\", false),
1952            (r"\a", r"\\\\", false),
1953            (r"\\a", r"\\\\", false),
1954            // Escaped non-wildcard
1955            (r"", r"\a", false),
1956            (r"\", r"\a", false),
1957            (r"\\", r"\a", false),
1958            (r"a", r"\a", true),
1959            (r"\a", r"\a", false),
1960            (r"\\a", r"\a", false),
1961            // Escaped _ wildcard
1962            (r"", r"\_", false),
1963            (r"\", r"\_", false),
1964            (r"\\", r"\_", false),
1965            (r"a", r"\_", false),
1966            (r"_", r"\_", true),
1967            (r"%", r"\_", false),
1968            (r"\a", r"\_", false),
1969            (r"\\a", r"\_", false),
1970            (r"\_", r"\_", false),
1971            (r"\\_", r"\_", false),
1972            // Escaped % wildcard
1973            (r"", r"\%", false),
1974            (r"\", r"\%", false),
1975            (r"\\", r"\%", false),
1976            (r"a", r"\%", false),
1977            (r"_", r"\%", false),
1978            (r"%", r"\%", true),
1979            (r"\a", r"\%", false),
1980            (r"\\a", r"\%", false),
1981            (r"\%", r"\%", false),
1982            (r"\\%", r"\%", false),
1983            // Escape and non-wildcard
1984            (r"", r"\\a", false),
1985            (r"\", r"\\a", false),
1986            (r"\\", r"\\a", false),
1987            (r"a", r"\\a", false),
1988            (r"\a", r"\\a", true),
1989            (r"\\a", r"\\a", false),
1990            (r"\\\a", r"\\a", false),
1991            // Escape and _ wildcard
1992            (r"", r"\\_", false),
1993            (r"\", r"\\_", false),
1994            (r"\\", r"\\_", true),
1995            (r"a", r"\\_", false),
1996            (r"_", r"\\_", false),
1997            (r"%", r"\\_", false),
1998            (r"\a", r"\\_", true),
1999            (r"\\a", r"\\_", false),
2000            (r"\_", r"\\_", true),
2001            (r"\\_", r"\\_", false),
2002            (r"\\\_", r"\\_", false),
2003            // Escape and % wildcard
2004            (r"", r"\\%", false),
2005            (r"\", r"\\%", true),
2006            (r"\\", r"\\%", true),
2007            (r"a", r"\\%", false),
2008            (r"ab", r"\\%", false),
2009            (r"a%", r"\\%", false),
2010            (r"_", r"\\%", false),
2011            (r"%", r"\\%", false),
2012            (r"\a", r"\\%", true),
2013            (r"\\a", r"\\%", true),
2014            (r"\%", r"\\%", true),
2015            (r"\\%", r"\\%", true),
2016            (r"\\\%", r"\\%", true),
2017            // %... pattern with dangling wildcard
2018            (r"\", r"%\", true),
2019            (r"\\", r"%\", true),
2020            (r"%\", r"%\", true),
2021            (r"%\\", r"%\", true),
2022            (r"abc\", r"%\", true),
2023            (r"abc", r"%\", false),
2024            // %... pattern with wildcard
2025            (r"\", r"%\\", true),
2026            (r"\\", r"%\\", true),
2027            (r"%\\", r"%\\", true),
2028            (r"%\\\", r"%\\", true),
2029            (r"abc\", r"%\\", true),
2030            (r"abc", r"%\\", false),
2031            // %... pattern including escaped non-wildcard
2032            (r"ac", r"%a\c", true),
2033            (r"xyzac", r"%a\c", true),
2034            (r"abc", r"%a\c", false),
2035            (r"a\c", r"%a\c", false),
2036            (r"%a\c", r"%a\c", false),
2037            // %... pattern including escape
2038            (r"\", r"%a\\c", false),
2039            (r"\\", r"%a\\c", false),
2040            (r"ac", r"%a\\c", false),
2041            (r"a\c", r"%a\\c", true),
2042            (r"a\\c", r"%a\\c", false),
2043            (r"abc", r"%a\\c", false),
2044            (r"xyza\c", r"%a\\c", true),
2045            (r"xyza\\c", r"%a\\c", false),
2046            (r"%a\\c", r"%a\\c", false),
2047            // ...% pattern with wildcard
2048            (r"\", r"\\%", true),
2049            (r"\\", r"\\%", true),
2050            (r"\\%", r"\\%", true),
2051            (r"\\\%", r"\\%", true),
2052            (r"\abc", r"\\%", true),
2053            (r"a", r"\\%", false),
2054            (r"abc", r"\\%", false),
2055            // ...% pattern including escaped non-wildcard
2056            (r"ac", r"a\c%", true),
2057            (r"acxyz", r"a\c%", true),
2058            (r"abc", r"a\c%", false),
2059            (r"a\c", r"a\c%", false),
2060            (r"a\c%", r"a\c%", false),
2061            (r"a\\c%", r"a\c%", false),
2062            // ...% pattern including escape
2063            (r"ac", r"a\\c%", false),
2064            (r"a\c", r"a\\c%", true),
2065            (r"a\cxyz", r"a\\c%", true),
2066            (r"a\\c", r"a\\c%", false),
2067            (r"a\\cxyz", r"a\\c%", false),
2068            (r"abc", r"a\\c%", false),
2069            (r"abcxyz", r"a\\c%", false),
2070            (r"a\\c%", r"a\\c%", false),
2071            // %...% pattern including escaped non-wildcard
2072            (r"ac", r"%a\c%", true),
2073            (r"xyzacxyz", r"%a\c%", true),
2074            (r"abc", r"%a\c%", false),
2075            (r"a\c", r"%a\c%", false),
2076            (r"xyza\cxyz", r"%a\c%", false),
2077            (r"%a\c%", r"%a\c%", false),
2078            (r"%a\\c%", r"%a\c%", false),
2079            // %...% pattern including escape
2080            (r"ac", r"%a\\c%", false),
2081            (r"a\c", r"%a\\c%", true),
2082            (r"xyza\cxyz", r"%a\\c%", true),
2083            (r"a\\c", r"%a\\c%", false),
2084            (r"xyza\\cxyz", r"%a\\c%", false),
2085            (r"abc", r"%a\\c%", false),
2086            (r"xyzabcxyz", r"%a\\c%", false),
2087            (r"%a\\c%", r"%a\\c%", false),
2088            // Odd (7) backslashes and % wildcard
2089            (r"\\%", r"\\\\\\\%", false),
2090            (r"\\\", r"\\\\\\\%", false),
2091            (r"\\\%", r"\\\\\\\%", true),
2092            (r"\\\\", r"\\\\\\\%", false),
2093            (r"\\\\%", r"\\\\\\\%", false),
2094            (r"\\\\\\\%", r"\\\\\\\%", false),
2095            // Odd (7) backslashes and _ wildcard
2096            (r"\\\", r"\\\\\\\_", false),
2097            (r"\\\\", r"\\\\\\\_", false),
2098            (r"\\\_", r"\\\\\\\_", true),
2099            (r"\\\\", r"\\\\\\\_", false),
2100            (r"\\\a", r"\\\\\\\_", false),
2101            (r"\\\\_", r"\\\\\\\_", false),
2102            (r"\\\\\\\_", r"\\\\\\\_", false),
2103            // Even (8) backslashes and % wildcard
2104            (r"\\\", r"\\\\\\\\%", false),
2105            (r"\\\\", r"\\\\\\\\%", true),
2106            (r"\\\\\", r"\\\\\\\\%", true),
2107            (r"\\\\xyz", r"\\\\\\\\%", true),
2108            (r"\\\\\\\\%", r"\\\\\\\\%", true),
2109            // Even (8) backslashes and _ wildcard
2110            (r"\\\", r"\\\\\\\\_", false),
2111            (r"\\\\", r"\\\\\\\\_", false),
2112            (r"\\\\\", r"\\\\\\\\_", true),
2113            (r"\\\\a", r"\\\\\\\\_", true),
2114            (r"\\\\\a", r"\\\\\\\\_", false),
2115            (r"\\\\ab", r"\\\\\\\\_", false),
2116            (r"\\\\\\\\_", r"\\\\\\\\_", false),
2117        ];
2118
2119        for (value, pattern, expected) in test_cases {
2120            let unexpected = BooleanArray::from(vec![!expected]);
2121            let expected = BooleanArray::from(vec![expected]);
2122
2123            for string_type in [DataType::Utf8, DataType::LargeUtf8, DataType::Utf8View] {
2124                for ((value_datum, value_type), (pattern_datum, pattern_type)) in zip(
2125                    make_datums(value, &string_type),
2126                    make_datums(pattern, &string_type),
2127                ) {
2128                    let value_datum = value_datum.as_ref();
2129                    let pattern_datum = pattern_datum.as_ref();
2130                    assert_eq!(
2131                        like(value_datum, pattern_datum).unwrap(),
2132                        expected,
2133                        "{value_type:?} «{value}» like {pattern_type:?} «{pattern}»"
2134                    );
2135                    assert_eq!(
2136                        ilike(value_datum, pattern_datum).unwrap(),
2137                        expected,
2138                        "{value_type:?} «{value}» ilike {pattern_type:?} «{pattern}»"
2139                    );
2140                    assert_eq!(
2141                        nlike(value_datum, pattern_datum).unwrap(),
2142                        unexpected,
2143                        "{value_type:?} «{value}» nlike {pattern_type:?} «{pattern}»"
2144                    );
2145                    assert_eq!(
2146                        nilike(value_datum, pattern_datum).unwrap(),
2147                        unexpected,
2148                        "{value_type:?} «{value}» nilike {pattern_type:?} «{pattern}»"
2149                    );
2150                }
2151            }
2152        }
2153    }
2154
2155    #[test]
2156    #[cfg_attr(miri, ignore)] // Takes too long
2157    fn like_escape_many() {
2158        // (value, pattern, expected)
2159        let test_cases = vec![
2160            (r"", r"", true),
2161            (r"\", r"", false),
2162            (r"\\", r"", false),
2163            (r"\\\", r"", false),
2164            (r"\\\\", r"", false),
2165            (r"a", r"", false),
2166            (r"\a", r"", false),
2167            (r"\\a", r"", false),
2168            (r"%", r"", false),
2169            (r"\%", r"", false),
2170            (r"\\%", r"", false),
2171            (r"%%", r"", false),
2172            (r"\%%", r"", false),
2173            (r"\\%%", r"", false),
2174            (r"_", r"", false),
2175            (r"\_", r"", false),
2176            (r"\\_", r"", false),
2177            (r"__", r"", false),
2178            (r"\__", r"", false),
2179            (r"\\__", r"", false),
2180            (r"abc", r"", false),
2181            (r"a_c", r"", false),
2182            (r"a\bc", r"", false),
2183            (r"a\_c", r"", false),
2184            (r"%abc", r"", false),
2185            (r"\%abc", r"", false),
2186            (r"a\\_c%", r"", false),
2187            (r"", r"\", false),
2188            (r"\", r"\", true),
2189            (r"\\", r"\", false),
2190            (r"\\\", r"\", false),
2191            (r"\\\\", r"\", false),
2192            (r"a", r"\", false),
2193            (r"\a", r"\", false),
2194            (r"\\a", r"\", false),
2195            (r"%", r"\", false),
2196            (r"\%", r"\", false),
2197            (r"\\%", r"\", false),
2198            (r"%%", r"\", false),
2199            (r"\%%", r"\", false),
2200            (r"\\%%", r"\", false),
2201            (r"_", r"\", false),
2202            (r"\_", r"\", false),
2203            (r"\\_", r"\", false),
2204            (r"__", r"\", false),
2205            (r"\__", r"\", false),
2206            (r"\\__", r"\", false),
2207            (r"abc", r"\", false),
2208            (r"a_c", r"\", false),
2209            (r"a\bc", r"\", false),
2210            (r"a\_c", r"\", false),
2211            (r"%abc", r"\", false),
2212            (r"\%abc", r"\", false),
2213            (r"a\\_c%", r"\", false),
2214            (r"", r"\\", false),
2215            (r"\", r"\\", true),
2216            (r"\\", r"\\", false),
2217            (r"\\\", r"\\", false),
2218            (r"\\\\", r"\\", false),
2219            (r"a", r"\\", false),
2220            (r"\a", r"\\", false),
2221            (r"\\a", r"\\", false),
2222            (r"%", r"\\", false),
2223            (r"\%", r"\\", false),
2224            (r"\\%", r"\\", false),
2225            (r"%%", r"\\", false),
2226            (r"\%%", r"\\", false),
2227            (r"\\%%", r"\\", false),
2228            (r"_", r"\\", false),
2229            (r"\_", r"\\", false),
2230            (r"\\_", r"\\", false),
2231            (r"__", r"\\", false),
2232            (r"\__", r"\\", false),
2233            (r"\\__", r"\\", false),
2234            (r"abc", r"\\", false),
2235            (r"a_c", r"\\", false),
2236            (r"a\bc", r"\\", false),
2237            (r"a\_c", r"\\", false),
2238            (r"%abc", r"\\", false),
2239            (r"\%abc", r"\\", false),
2240            (r"a\\_c%", r"\\", false),
2241            (r"", r"\\\", false),
2242            (r"\", r"\\\", false),
2243            (r"\\", r"\\\", true),
2244            (r"\\\", r"\\\", false),
2245            (r"\\\\", r"\\\", false),
2246            (r"a", r"\\\", false),
2247            (r"\a", r"\\\", false),
2248            (r"\\a", r"\\\", false),
2249            (r"%", r"\\\", false),
2250            (r"\%", r"\\\", false),
2251            (r"\\%", r"\\\", false),
2252            (r"%%", r"\\\", false),
2253            (r"\%%", r"\\\", false),
2254            (r"\\%%", r"\\\", false),
2255            (r"_", r"\\\", false),
2256            (r"\_", r"\\\", false),
2257            (r"\\_", r"\\\", false),
2258            (r"__", r"\\\", false),
2259            (r"\__", r"\\\", false),
2260            (r"\\__", r"\\\", false),
2261            (r"abc", r"\\\", false),
2262            (r"a_c", r"\\\", false),
2263            (r"a\bc", r"\\\", false),
2264            (r"a\_c", r"\\\", false),
2265            (r"%abc", r"\\\", false),
2266            (r"\%abc", r"\\\", false),
2267            (r"a\\_c%", r"\\\", false),
2268            (r"", r"\\\\", false),
2269            (r"\", r"\\\\", false),
2270            (r"\\", r"\\\\", true),
2271            (r"\\\", r"\\\\", false),
2272            (r"\\\\", r"\\\\", false),
2273            (r"a", r"\\\\", false),
2274            (r"\a", r"\\\\", false),
2275            (r"\\a", r"\\\\", false),
2276            (r"%", r"\\\\", false),
2277            (r"\%", r"\\\\", false),
2278            (r"\\%", r"\\\\", false),
2279            (r"%%", r"\\\\", false),
2280            (r"\%%", r"\\\\", false),
2281            (r"\\%%", r"\\\\", false),
2282            (r"_", r"\\\\", false),
2283            (r"\_", r"\\\\", false),
2284            (r"\\_", r"\\\\", false),
2285            (r"__", r"\\\\", false),
2286            (r"\__", r"\\\\", false),
2287            (r"\\__", r"\\\\", false),
2288            (r"abc", r"\\\\", false),
2289            (r"a_c", r"\\\\", false),
2290            (r"a\bc", r"\\\\", false),
2291            (r"a\_c", r"\\\\", false),
2292            (r"%abc", r"\\\\", false),
2293            (r"\%abc", r"\\\\", false),
2294            (r"a\\_c%", r"\\\\", false),
2295            (r"", r"a", false),
2296            (r"\", r"a", false),
2297            (r"\\", r"a", false),
2298            (r"\\\", r"a", false),
2299            (r"\\\\", r"a", false),
2300            (r"a", r"a", true),
2301            (r"\a", r"a", false),
2302            (r"\\a", r"a", false),
2303            (r"%", r"a", false),
2304            (r"\%", r"a", false),
2305            (r"\\%", r"a", false),
2306            (r"%%", r"a", false),
2307            (r"\%%", r"a", false),
2308            (r"\\%%", r"a", false),
2309            (r"_", r"a", false),
2310            (r"\_", r"a", false),
2311            (r"\\_", r"a", false),
2312            (r"__", r"a", false),
2313            (r"\__", r"a", false),
2314            (r"\\__", r"a", false),
2315            (r"abc", r"a", false),
2316            (r"a_c", r"a", false),
2317            (r"a\bc", r"a", false),
2318            (r"a\_c", r"a", false),
2319            (r"%abc", r"a", false),
2320            (r"\%abc", r"a", false),
2321            (r"a\\_c%", r"a", false),
2322            (r"", r"\a", false),
2323            (r"\", r"\a", false),
2324            (r"\\", r"\a", false),
2325            (r"\\\", r"\a", false),
2326            (r"\\\\", r"\a", false),
2327            (r"a", r"\a", true),
2328            (r"\a", r"\a", false),
2329            (r"\\a", r"\a", false),
2330            (r"%", r"\a", false),
2331            (r"\%", r"\a", false),
2332            (r"\\%", r"\a", false),
2333            (r"%%", r"\a", false),
2334            (r"\%%", r"\a", false),
2335            (r"\\%%", r"\a", false),
2336            (r"_", r"\a", false),
2337            (r"\_", r"\a", false),
2338            (r"\\_", r"\a", false),
2339            (r"__", r"\a", false),
2340            (r"\__", r"\a", false),
2341            (r"\\__", r"\a", false),
2342            (r"abc", r"\a", false),
2343            (r"a_c", r"\a", false),
2344            (r"a\bc", r"\a", false),
2345            (r"a\_c", r"\a", false),
2346            (r"%abc", r"\a", false),
2347            (r"\%abc", r"\a", false),
2348            (r"a\\_c%", r"\a", false),
2349            (r"", r"\\a", false),
2350            (r"\", r"\\a", false),
2351            (r"\\", r"\\a", false),
2352            (r"\\\", r"\\a", false),
2353            (r"\\\\", r"\\a", false),
2354            (r"a", r"\\a", false),
2355            (r"\a", r"\\a", true),
2356            (r"\\a", r"\\a", false),
2357            (r"%", r"\\a", false),
2358            (r"\%", r"\\a", false),
2359            (r"\\%", r"\\a", false),
2360            (r"%%", r"\\a", false),
2361            (r"\%%", r"\\a", false),
2362            (r"\\%%", r"\\a", false),
2363            (r"_", r"\\a", false),
2364            (r"\_", r"\\a", false),
2365            (r"\\_", r"\\a", false),
2366            (r"__", r"\\a", false),
2367            (r"\__", r"\\a", false),
2368            (r"\\__", r"\\a", false),
2369            (r"abc", r"\\a", false),
2370            (r"a_c", r"\\a", false),
2371            (r"a\bc", r"\\a", false),
2372            (r"a\_c", r"\\a", false),
2373            (r"%abc", r"\\a", false),
2374            (r"\%abc", r"\\a", false),
2375            (r"a\\_c%", r"\\a", false),
2376            (r"", r"%", true),
2377            (r"\", r"%", true),
2378            (r"\\", r"%", true),
2379            (r"\\\", r"%", true),
2380            (r"\\\\", r"%", true),
2381            (r"a", r"%", true),
2382            (r"\a", r"%", true),
2383            (r"\\a", r"%", true),
2384            (r"%", r"%", true),
2385            (r"\%", r"%", true),
2386            (r"\\%", r"%", true),
2387            (r"%%", r"%", true),
2388            (r"\%%", r"%", true),
2389            (r"\\%%", r"%", true),
2390            (r"_", r"%", true),
2391            (r"\_", r"%", true),
2392            (r"\\_", r"%", true),
2393            (r"__", r"%", true),
2394            (r"\__", r"%", true),
2395            (r"\\__", r"%", true),
2396            (r"abc", r"%", true),
2397            (r"a_c", r"%", true),
2398            (r"a\bc", r"%", true),
2399            (r"a\_c", r"%", true),
2400            (r"%abc", r"%", true),
2401            (r"\%abc", r"%", true),
2402            (r"a\\_c%", r"%", true),
2403            (r"", r"\%", false),
2404            (r"\", r"\%", false),
2405            (r"\\", r"\%", false),
2406            (r"\\\", r"\%", false),
2407            (r"\\\\", r"\%", false),
2408            (r"a", r"\%", false),
2409            (r"\a", r"\%", false),
2410            (r"\\a", r"\%", false),
2411            (r"%", r"\%", true),
2412            (r"\%", r"\%", false),
2413            (r"\\%", r"\%", false),
2414            (r"%%", r"\%", false),
2415            (r"\%%", r"\%", false),
2416            (r"\\%%", r"\%", false),
2417            (r"_", r"\%", false),
2418            (r"\_", r"\%", false),
2419            (r"\\_", r"\%", false),
2420            (r"__", r"\%", false),
2421            (r"\__", r"\%", false),
2422            (r"\\__", r"\%", false),
2423            (r"abc", r"\%", false),
2424            (r"a_c", r"\%", false),
2425            (r"a\bc", r"\%", false),
2426            (r"a\_c", r"\%", false),
2427            (r"%abc", r"\%", false),
2428            (r"\%abc", r"\%", false),
2429            (r"a\\_c%", r"\%", false),
2430            (r"", r"\\%", false),
2431            (r"\", r"\\%", true),
2432            (r"\\", r"\\%", true),
2433            (r"\\\", r"\\%", true),
2434            (r"\\\\", r"\\%", true),
2435            (r"a", r"\\%", false),
2436            (r"\a", r"\\%", true),
2437            (r"\\a", r"\\%", true),
2438            (r"%", r"\\%", false),
2439            (r"\%", r"\\%", true),
2440            (r"\\%", r"\\%", true),
2441            (r"%%", r"\\%", false),
2442            (r"\%%", r"\\%", true),
2443            (r"\\%%", r"\\%", true),
2444            (r"_", r"\\%", false),
2445            (r"\_", r"\\%", true),
2446            (r"\\_", r"\\%", true),
2447            (r"__", r"\\%", false),
2448            (r"\__", r"\\%", true),
2449            (r"\\__", r"\\%", true),
2450            (r"abc", r"\\%", false),
2451            (r"a_c", r"\\%", false),
2452            (r"a\bc", r"\\%", false),
2453            (r"a\_c", r"\\%", false),
2454            (r"%abc", r"\\%", false),
2455            (r"\%abc", r"\\%", true),
2456            (r"a\\_c%", r"\\%", false),
2457            (r"", r"%%", true),
2458            (r"\", r"%%", true),
2459            (r"\\", r"%%", true),
2460            (r"\\\", r"%%", true),
2461            (r"\\\\", r"%%", true),
2462            (r"a", r"%%", true),
2463            (r"\a", r"%%", true),
2464            (r"\\a", r"%%", true),
2465            (r"%", r"%%", true),
2466            (r"\%", r"%%", true),
2467            (r"\\%", r"%%", true),
2468            (r"%%", r"%%", true),
2469            (r"\%%", r"%%", true),
2470            (r"\\%%", r"%%", true),
2471            (r"_", r"%%", true),
2472            (r"\_", r"%%", true),
2473            (r"\\_", r"%%", true),
2474            (r"__", r"%%", true),
2475            (r"\__", r"%%", true),
2476            (r"\\__", r"%%", true),
2477            (r"abc", r"%%", true),
2478            (r"a_c", r"%%", true),
2479            (r"a\bc", r"%%", true),
2480            (r"a\_c", r"%%", true),
2481            (r"%abc", r"%%", true),
2482            (r"\%abc", r"%%", true),
2483            (r"a\\_c%", r"%%", true),
2484            (r"", r"\%%", false),
2485            (r"\", r"\%%", false),
2486            (r"\\", r"\%%", false),
2487            (r"\\\", r"\%%", false),
2488            (r"\\\\", r"\%%", false),
2489            (r"a", r"\%%", false),
2490            (r"\a", r"\%%", false),
2491            (r"\\a", r"\%%", false),
2492            (r"%", r"\%%", true),
2493            (r"\%", r"\%%", false),
2494            (r"\\%", r"\%%", false),
2495            (r"%%", r"\%%", true),
2496            (r"\%%", r"\%%", false),
2497            (r"\\%%", r"\%%", false),
2498            (r"_", r"\%%", false),
2499            (r"\_", r"\%%", false),
2500            (r"\\_", r"\%%", false),
2501            (r"__", r"\%%", false),
2502            (r"\__", r"\%%", false),
2503            (r"\\__", r"\%%", false),
2504            (r"abc", r"\%%", false),
2505            (r"a_c", r"\%%", false),
2506            (r"a\bc", r"\%%", false),
2507            (r"a\_c", r"\%%", false),
2508            (r"%abc", r"\%%", true),
2509            (r"\%abc", r"\%%", false),
2510            (r"a\\_c%", r"\%%", false),
2511            (r"", r"\\%%", false),
2512            (r"\", r"\\%%", true),
2513            (r"\\", r"\\%%", true),
2514            (r"\\\", r"\\%%", true),
2515            (r"\\\\", r"\\%%", true),
2516            (r"a", r"\\%%", false),
2517            (r"\a", r"\\%%", true),
2518            (r"\\a", r"\\%%", true),
2519            (r"%", r"\\%%", false),
2520            (r"\%", r"\\%%", true),
2521            (r"\\%", r"\\%%", true),
2522            (r"%%", r"\\%%", false),
2523            (r"\%%", r"\\%%", true),
2524            (r"\\%%", r"\\%%", true),
2525            (r"_", r"\\%%", false),
2526            (r"\_", r"\\%%", true),
2527            (r"\\_", r"\\%%", true),
2528            (r"__", r"\\%%", false),
2529            (r"\__", r"\\%%", true),
2530            (r"\\__", r"\\%%", true),
2531            (r"abc", r"\\%%", false),
2532            (r"a_c", r"\\%%", false),
2533            (r"a\bc", r"\\%%", false),
2534            (r"a\_c", r"\\%%", false),
2535            (r"%abc", r"\\%%", false),
2536            (r"\%abc", r"\\%%", true),
2537            (r"a\\_c%", r"\\%%", false),
2538            (r"", r"_", false),
2539            (r"\", r"_", true),
2540            (r"\\", r"_", false),
2541            (r"\\\", r"_", false),
2542            (r"\\\\", r"_", false),
2543            (r"a", r"_", true),
2544            (r"\a", r"_", false),
2545            (r"\\a", r"_", false),
2546            (r"%", r"_", true),
2547            (r"\%", r"_", false),
2548            (r"\\%", r"_", false),
2549            (r"%%", r"_", false),
2550            (r"\%%", r"_", false),
2551            (r"\\%%", r"_", false),
2552            (r"_", r"_", true),
2553            (r"\_", r"_", false),
2554            (r"\\_", r"_", false),
2555            (r"__", r"_", false),
2556            (r"\__", r"_", false),
2557            (r"\\__", r"_", false),
2558            (r"abc", r"_", false),
2559            (r"a_c", r"_", false),
2560            (r"a\bc", r"_", false),
2561            (r"a\_c", r"_", false),
2562            (r"%abc", r"_", false),
2563            (r"\%abc", r"_", false),
2564            (r"a\\_c%", r"_", false),
2565            (r"", r"\_", false),
2566            (r"\", r"\_", false),
2567            (r"\\", r"\_", false),
2568            (r"\\\", r"\_", false),
2569            (r"\\\\", r"\_", false),
2570            (r"a", r"\_", false),
2571            (r"\a", r"\_", false),
2572            (r"\\a", r"\_", false),
2573            (r"%", r"\_", false),
2574            (r"\%", r"\_", false),
2575            (r"\\%", r"\_", false),
2576            (r"%%", r"\_", false),
2577            (r"\%%", r"\_", false),
2578            (r"\\%%", r"\_", false),
2579            (r"_", r"\_", true),
2580            (r"\_", r"\_", false),
2581            (r"\\_", r"\_", false),
2582            (r"__", r"\_", false),
2583            (r"\__", r"\_", false),
2584            (r"\\__", r"\_", false),
2585            (r"abc", r"\_", false),
2586            (r"a_c", r"\_", false),
2587            (r"a\bc", r"\_", false),
2588            (r"a\_c", r"\_", false),
2589            (r"%abc", r"\_", false),
2590            (r"\%abc", r"\_", false),
2591            (r"a\\_c%", r"\_", false),
2592            (r"", r"\\_", false),
2593            (r"\", r"\\_", false),
2594            (r"\\", r"\\_", true),
2595            (r"\\\", r"\\_", false),
2596            (r"\\\\", r"\\_", false),
2597            (r"a", r"\\_", false),
2598            (r"\a", r"\\_", true),
2599            (r"\\a", r"\\_", false),
2600            (r"%", r"\\_", false),
2601            (r"\%", r"\\_", true),
2602            (r"\\%", r"\\_", false),
2603            (r"%%", r"\\_", false),
2604            (r"\%%", r"\\_", false),
2605            (r"\\%%", r"\\_", false),
2606            (r"_", r"\\_", false),
2607            (r"\_", r"\\_", true),
2608            (r"\\_", r"\\_", false),
2609            (r"__", r"\\_", false),
2610            (r"\__", r"\\_", false),
2611            (r"\\__", r"\\_", false),
2612            (r"abc", r"\\_", false),
2613            (r"a_c", r"\\_", false),
2614            (r"a\bc", r"\\_", false),
2615            (r"a\_c", r"\\_", false),
2616            (r"%abc", r"\\_", false),
2617            (r"\%abc", r"\\_", false),
2618            (r"a\\_c%", r"\\_", false),
2619            (r"", r"__", false),
2620            (r"\", r"__", false),
2621            (r"\\", r"__", true),
2622            (r"\\\", r"__", false),
2623            (r"\\\\", r"__", false),
2624            (r"a", r"__", false),
2625            (r"\a", r"__", true),
2626            (r"\\a", r"__", false),
2627            (r"%", r"__", false),
2628            (r"\%", r"__", true),
2629            (r"\\%", r"__", false),
2630            (r"%%", r"__", true),
2631            (r"\%%", r"__", false),
2632            (r"\\%%", r"__", false),
2633            (r"_", r"__", false),
2634            (r"\_", r"__", true),
2635            (r"\\_", r"__", false),
2636            (r"__", r"__", true),
2637            (r"\__", r"__", false),
2638            (r"\\__", r"__", false),
2639            (r"abc", r"__", false),
2640            (r"a_c", r"__", false),
2641            (r"a\bc", r"__", false),
2642            (r"a\_c", r"__", false),
2643            (r"%abc", r"__", false),
2644            (r"\%abc", r"__", false),
2645            (r"a\\_c%", r"__", false),
2646            (r"", r"\__", false),
2647            (r"\", r"\__", false),
2648            (r"\\", r"\__", false),
2649            (r"\\\", r"\__", false),
2650            (r"\\\\", r"\__", false),
2651            (r"a", r"\__", false),
2652            (r"\a", r"\__", false),
2653            (r"\\a", r"\__", false),
2654            (r"%", r"\__", false),
2655            (r"\%", r"\__", false),
2656            (r"\\%", r"\__", false),
2657            (r"%%", r"\__", false),
2658            (r"\%%", r"\__", false),
2659            (r"\\%%", r"\__", false),
2660            (r"_", r"\__", false),
2661            (r"\_", r"\__", false),
2662            (r"\\_", r"\__", false),
2663            (r"__", r"\__", true),
2664            (r"\__", r"\__", false),
2665            (r"\\__", r"\__", false),
2666            (r"abc", r"\__", false),
2667            (r"a_c", r"\__", false),
2668            (r"a\bc", r"\__", false),
2669            (r"a\_c", r"\__", false),
2670            (r"%abc", r"\__", false),
2671            (r"\%abc", r"\__", false),
2672            (r"a\\_c%", r"\__", false),
2673            (r"", r"\\__", false),
2674            (r"\", r"\\__", false),
2675            (r"\\", r"\\__", false),
2676            (r"\\\", r"\\__", true),
2677            (r"\\\\", r"\\__", false),
2678            (r"a", r"\\__", false),
2679            (r"\a", r"\\__", false),
2680            (r"\\a", r"\\__", true),
2681            (r"%", r"\\__", false),
2682            (r"\%", r"\\__", false),
2683            (r"\\%", r"\\__", true),
2684            (r"%%", r"\\__", false),
2685            (r"\%%", r"\\__", true),
2686            (r"\\%%", r"\\__", false),
2687            (r"_", r"\\__", false),
2688            (r"\_", r"\\__", false),
2689            (r"\\_", r"\\__", true),
2690            (r"__", r"\\__", false),
2691            (r"\__", r"\\__", true),
2692            (r"\\__", r"\\__", false),
2693            (r"abc", r"\\__", false),
2694            (r"a_c", r"\\__", false),
2695            (r"a\bc", r"\\__", false),
2696            (r"a\_c", r"\\__", false),
2697            (r"%abc", r"\\__", false),
2698            (r"\%abc", r"\\__", false),
2699            (r"a\\_c%", r"\\__", false),
2700            (r"", r"abc", false),
2701            (r"\", r"abc", false),
2702            (r"\\", r"abc", false),
2703            (r"\\\", r"abc", false),
2704            (r"\\\\", r"abc", false),
2705            (r"a", r"abc", false),
2706            (r"\a", r"abc", false),
2707            (r"\\a", r"abc", false),
2708            (r"%", r"abc", false),
2709            (r"\%", r"abc", false),
2710            (r"\\%", r"abc", false),
2711            (r"%%", r"abc", false),
2712            (r"\%%", r"abc", false),
2713            (r"\\%%", r"abc", false),
2714            (r"_", r"abc", false),
2715            (r"\_", r"abc", false),
2716            (r"\\_", r"abc", false),
2717            (r"__", r"abc", false),
2718            (r"\__", r"abc", false),
2719            (r"\\__", r"abc", false),
2720            (r"abc", r"abc", true),
2721            (r"a_c", r"abc", false),
2722            (r"a\bc", r"abc", false),
2723            (r"a\_c", r"abc", false),
2724            (r"%abc", r"abc", false),
2725            (r"\%abc", r"abc", false),
2726            (r"a\\_c%", r"abc", false),
2727            (r"", r"a_c", false),
2728            (r"\", r"a_c", false),
2729            (r"\\", r"a_c", false),
2730            (r"\\\", r"a_c", false),
2731            (r"\\\\", r"a_c", false),
2732            (r"a", r"a_c", false),
2733            (r"\a", r"a_c", false),
2734            (r"\\a", r"a_c", false),
2735            (r"%", r"a_c", false),
2736            (r"\%", r"a_c", false),
2737            (r"\\%", r"a_c", false),
2738            (r"%%", r"a_c", false),
2739            (r"\%%", r"a_c", false),
2740            (r"\\%%", r"a_c", false),
2741            (r"_", r"a_c", false),
2742            (r"\_", r"a_c", false),
2743            (r"\\_", r"a_c", false),
2744            (r"__", r"a_c", false),
2745            (r"\__", r"a_c", false),
2746            (r"\\__", r"a_c", false),
2747            (r"abc", r"a_c", true),
2748            (r"a_c", r"a_c", true),
2749            (r"a\bc", r"a_c", false),
2750            (r"a\_c", r"a_c", false),
2751            (r"%abc", r"a_c", false),
2752            (r"\%abc", r"a_c", false),
2753            (r"a\\_c%", r"a_c", false),
2754            (r"", r"a\bc", false),
2755            (r"\", r"a\bc", false),
2756            (r"\\", r"a\bc", false),
2757            (r"\\\", r"a\bc", false),
2758            (r"\\\\", r"a\bc", false),
2759            (r"a", r"a\bc", false),
2760            (r"\a", r"a\bc", false),
2761            (r"\\a", r"a\bc", false),
2762            (r"%", r"a\bc", false),
2763            (r"\%", r"a\bc", false),
2764            (r"\\%", r"a\bc", false),
2765            (r"%%", r"a\bc", false),
2766            (r"\%%", r"a\bc", false),
2767            (r"\\%%", r"a\bc", false),
2768            (r"_", r"a\bc", false),
2769            (r"\_", r"a\bc", false),
2770            (r"\\_", r"a\bc", false),
2771            (r"__", r"a\bc", false),
2772            (r"\__", r"a\bc", false),
2773            (r"\\__", r"a\bc", false),
2774            (r"abc", r"a\bc", true),
2775            (r"a_c", r"a\bc", false),
2776            (r"a\bc", r"a\bc", false),
2777            (r"a\_c", r"a\bc", false),
2778            (r"%abc", r"a\bc", false),
2779            (r"\%abc", r"a\bc", false),
2780            (r"a\\_c%", r"a\bc", false),
2781            (r"", r"a\_c", false),
2782            (r"\", r"a\_c", false),
2783            (r"\\", r"a\_c", false),
2784            (r"\\\", r"a\_c", false),
2785            (r"\\\\", r"a\_c", false),
2786            (r"a", r"a\_c", false),
2787            (r"\a", r"a\_c", false),
2788            (r"\\a", r"a\_c", false),
2789            (r"%", r"a\_c", false),
2790            (r"\%", r"a\_c", false),
2791            (r"\\%", r"a\_c", false),
2792            (r"%%", r"a\_c", false),
2793            (r"\%%", r"a\_c", false),
2794            (r"\\%%", r"a\_c", false),
2795            (r"_", r"a\_c", false),
2796            (r"\_", r"a\_c", false),
2797            (r"\\_", r"a\_c", false),
2798            (r"__", r"a\_c", false),
2799            (r"\__", r"a\_c", false),
2800            (r"\\__", r"a\_c", false),
2801            (r"abc", r"a\_c", false),
2802            (r"a_c", r"a\_c", true),
2803            (r"a\bc", r"a\_c", false),
2804            (r"a\_c", r"a\_c", false),
2805            (r"%abc", r"a\_c", false),
2806            (r"\%abc", r"a\_c", false),
2807            (r"a\\_c%", r"a\_c", false),
2808            (r"", r"%abc", false),
2809            (r"\", r"%abc", false),
2810            (r"\\", r"%abc", false),
2811            (r"\\\", r"%abc", false),
2812            (r"\\\\", r"%abc", false),
2813            (r"a", r"%abc", false),
2814            (r"\a", r"%abc", false),
2815            (r"\\a", r"%abc", false),
2816            (r"%", r"%abc", false),
2817            (r"\%", r"%abc", false),
2818            (r"\\%", r"%abc", false),
2819            (r"%%", r"%abc", false),
2820            (r"\%%", r"%abc", false),
2821            (r"\\%%", r"%abc", false),
2822            (r"_", r"%abc", false),
2823            (r"\_", r"%abc", false),
2824            (r"\\_", r"%abc", false),
2825            (r"__", r"%abc", false),
2826            (r"\__", r"%abc", false),
2827            (r"\\__", r"%abc", false),
2828            (r"abc", r"%abc", true),
2829            (r"a_c", r"%abc", false),
2830            (r"a\bc", r"%abc", false),
2831            (r"a\_c", r"%abc", false),
2832            (r"%abc", r"%abc", true),
2833            (r"\%abc", r"%abc", true),
2834            (r"a\\_c%", r"%abc", false),
2835            (r"", r"\%abc", false),
2836            (r"\", r"\%abc", false),
2837            (r"\\", r"\%abc", false),
2838            (r"\\\", r"\%abc", false),
2839            (r"\\\\", r"\%abc", false),
2840            (r"a", r"\%abc", false),
2841            (r"\a", r"\%abc", false),
2842            (r"\\a", r"\%abc", false),
2843            (r"%", r"\%abc", false),
2844            (r"\%", r"\%abc", false),
2845            (r"\\%", r"\%abc", false),
2846            (r"%%", r"\%abc", false),
2847            (r"\%%", r"\%abc", false),
2848            (r"\\%%", r"\%abc", false),
2849            (r"_", r"\%abc", false),
2850            (r"\_", r"\%abc", false),
2851            (r"\\_", r"\%abc", false),
2852            (r"__", r"\%abc", false),
2853            (r"\__", r"\%abc", false),
2854            (r"\\__", r"\%abc", false),
2855            (r"abc", r"\%abc", false),
2856            (r"a_c", r"\%abc", false),
2857            (r"a\bc", r"\%abc", false),
2858            (r"a\_c", r"\%abc", false),
2859            (r"%abc", r"\%abc", true),
2860            (r"\%abc", r"\%abc", false),
2861            (r"a\\_c%", r"\%abc", false),
2862            (r"", r"a\\_c%", false),
2863            (r"\", r"a\\_c%", false),
2864            (r"\\", r"a\\_c%", false),
2865            (r"\\\", r"a\\_c%", false),
2866            (r"\\\\", r"a\\_c%", false),
2867            (r"a", r"a\\_c%", false),
2868            (r"\a", r"a\\_c%", false),
2869            (r"\\a", r"a\\_c%", false),
2870            (r"%", r"a\\_c%", false),
2871            (r"\%", r"a\\_c%", false),
2872            (r"\\%", r"a\\_c%", false),
2873            (r"%%", r"a\\_c%", false),
2874            (r"\%%", r"a\\_c%", false),
2875            (r"\\%%", r"a\\_c%", false),
2876            (r"_", r"a\\_c%", false),
2877            (r"\_", r"a\\_c%", false),
2878            (r"\\_", r"a\\_c%", false),
2879            (r"__", r"a\\_c%", false),
2880            (r"\__", r"a\\_c%", false),
2881            (r"\\__", r"a\\_c%", false),
2882            (r"abc", r"a\\_c%", false),
2883            (r"a_c", r"a\\_c%", false),
2884            (r"a\bc", r"a\\_c%", true),
2885            (r"a\_c", r"a\\_c%", true),
2886            (r"%abc", r"a\\_c%", false),
2887            (r"\%abc", r"a\\_c%", false),
2888            (r"a\\_c%", r"a\\_c%", false),
2889        ];
2890
2891        let values = test_cases
2892            .iter()
2893            .map(|(value, _, _)| *value)
2894            .collect::<Vec<_>>();
2895        let patterns = test_cases
2896            .iter()
2897            .map(|(_, pattern, _)| *pattern)
2898            .collect::<Vec<_>>();
2899        let expected = BooleanArray::from(
2900            test_cases
2901                .iter()
2902                .map(|(_, _, expected)| *expected)
2903                .collect::<Vec<_>>(),
2904        );
2905        let unexpected = BooleanArray::from(
2906            test_cases
2907                .iter()
2908                .map(|(_, _, expected)| !*expected)
2909                .collect::<Vec<_>>(),
2910        );
2911
2912        for string_type in [DataType::Utf8, DataType::LargeUtf8, DataType::Utf8View] {
2913            let values = make_array(values.iter(), &string_type);
2914            let patterns = make_array(patterns.iter(), &string_type);
2915            let (values, patterns) = (values.as_ref(), patterns.as_ref());
2916
2917            assert_eq!(like(&values, &patterns).unwrap(), expected,);
2918            assert_eq!(ilike(&values, &patterns).unwrap(), expected,);
2919            assert_eq!(nlike(&values, &patterns).unwrap(), unexpected,);
2920            assert_eq!(nilike(&values, &patterns).unwrap(), unexpected,);
2921        }
2922    }
2923
2924    fn make_datums(
2925        value: impl AsRef<str>,
2926        data_type: &DataType,
2927    ) -> Vec<(Box<dyn Datum>, DatumType)> {
2928        match data_type {
2929            DataType::Utf8 => {
2930                let array = StringArray::from_iter_values([value]);
2931                vec![
2932                    (Box::new(array.clone()), DatumType::Array),
2933                    (Box::new(Scalar::new(array)), DatumType::Scalar),
2934                ]
2935            }
2936            DataType::LargeUtf8 => {
2937                let array = LargeStringArray::from_iter_values([value]);
2938                vec![
2939                    (Box::new(array.clone()), DatumType::Array),
2940                    (Box::new(Scalar::new(array)), DatumType::Scalar),
2941                ]
2942            }
2943            DataType::Utf8View => {
2944                let array = StringViewArray::from_iter_values([value]);
2945                vec![
2946                    (Box::new(array.clone()), DatumType::Array),
2947                    (Box::new(Scalar::new(array)), DatumType::Scalar),
2948                ]
2949            }
2950            _ => unimplemented!(),
2951        }
2952    }
2953
2954    fn make_array(
2955        values: impl IntoIterator<Item: AsRef<str>>,
2956        data_type: &DataType,
2957    ) -> Box<dyn Array> {
2958        match data_type {
2959            DataType::Utf8 => Box::new(StringArray::from_iter_values(values)),
2960            DataType::LargeUtf8 => Box::new(LargeStringArray::from_iter_values(values)),
2961            DataType::Utf8View => Box::new(StringViewArray::from_iter_values(values)),
2962            _ => unimplemented!(),
2963        }
2964    }
2965
2966    #[derive(Debug)]
2967    enum DatumType {
2968        Array,
2969        Scalar,
2970    }
2971}