1use 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
50pub fn like(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
78 like_op(Op::Like(false), left, right)
79}
80
81pub fn ilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
89 like_op(Op::ILike(false), left, right)
90}
91
92pub fn nlike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
98 like_op(Op::Like(true), left, right)
99}
100
101pub fn nilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
107 like_op(Op::ILike(true), left, right)
108}
109
110pub fn starts_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
136 like_op(Op::StartsWith, left, right)
137}
138
139pub fn ends_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
165 like_op(Op::EndsWith, left, right)
166}
167
168pub fn contains(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
194 like_op(Op::Contains, left, right)
195}
196
197pub 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
308fn 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 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 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 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
349fn 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
357fn 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
384fn 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 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 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 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 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 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 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)] 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 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 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)] 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)] 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)] 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)] 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)] 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 test_utf8_scalar!(
1211 #[cfg_attr(miri, ignore)] 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)] 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)] 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)] 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 test_utf8_and_binary_scalar!(
1302 test_utf8_and_binary_array_contains_unicode_contains,
1303 vec![
1304 "sdlkdfFkoßsdfs",
1305 "sdlkdFFkoSSdggs", "sdlkdFFkoSSsdsd", "FkoS",
1308 "Fkos",
1309 "ffkoSS",
1310 "ffkoß",
1311 "😃sadlksFFkoSSsh😃klF", "😱slgFFkoSSsh😃klF", "FFkoSS", "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)] 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 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)] 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)] 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)] 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)] 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 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)] 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)] fn string_null_like_pattern() {
1587 for pattern in &[
1589 "", "_", "%", "a%", "%a", "a%b", "%a%", "%a%b_c_d%e", ] {
1598 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)] fn string_view_null_like_pattern() {
1634 for pattern in &[
1636 "", "_", "%", "a%", "%a", "a%b", "%a%", "%a%b_c_d%e", ] {
1645 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 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 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)] fn like_escape() {
1916 let test_cases = vec![
1918 (r"", r"", true),
1920 (r"\", r"", false),
1921 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (r"\\%", r"\\\\\\\%", false),
2090 (r"\\\", r"\\\\\\\%", false),
2091 (r"\\\%", r"\\\\\\\%", true),
2092 (r"\\\\", r"\\\\\\\%", false),
2093 (r"\\\\%", r"\\\\\\\%", false),
2094 (r"\\\\\\\%", r"\\\\\\\%", false),
2095 (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 (r"\\\", r"\\\\\\\\%", false),
2105 (r"\\\\", r"\\\\\\\\%", true),
2106 (r"\\\\\", r"\\\\\\\\%", true),
2107 (r"\\\\xyz", r"\\\\\\\\%", true),
2108 (r"\\\\\\\\%", r"\\\\\\\\%", true),
2109 (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)] fn like_escape_many() {
2158 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}