1use arrow_array::cast::*;
27
28use arrow_array::*;
29use arrow_buffer::{bit_util, BooleanBuffer, MutableBuffer, NullBuffer};
30use arrow_schema::ArrowError;
31
32pub fn in_list<T, OffsetSize>(
34 left: &PrimitiveArray<T>,
35 right: &GenericListArray<OffsetSize>,
36) -> Result<BooleanArray, ArrowError>
37where
38 T: ArrowNumericType,
39 OffsetSize: OffsetSizeTrait,
40{
41 let left_len = left.len();
42 if left_len != right.len() {
43 return Err(ArrowError::ComputeError(
44 "Cannot perform comparison operation on arrays of different length".to_string(),
45 ));
46 }
47
48 let num_bytes = bit_util::ceil(left_len, 8);
49
50 let nulls = NullBuffer::union(left.nulls(), right.nulls());
51 let mut bool_buf = MutableBuffer::from_len_zeroed(num_bytes);
52 let bool_slice = bool_buf.as_slice_mut();
53
54 for i in 0..left_len {
56 if nulls.as_ref().map(|n| n.is_valid(i)).unwrap_or(true) {
57 let list = right.value(i);
58 let list = list.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap();
59
60 for j in 0..list.len() {
61 if list.is_valid(j) && (left.value(i) == list.value(j)) {
62 bit_util::set_bit(bool_slice, i);
63 continue;
64 }
65 }
66 }
67 }
68
69 let values = BooleanBuffer::new(bool_buf.into(), 0, left_len);
70 Ok(BooleanArray::new(values, None))
71}
72
73pub fn in_list_utf8<OffsetSize>(
75 left: &GenericStringArray<OffsetSize>,
76 right: &ListArray,
77) -> Result<BooleanArray, ArrowError>
78where
79 OffsetSize: OffsetSizeTrait,
80{
81 let left_len = left.len();
82 if left_len != right.len() {
83 return Err(ArrowError::ComputeError(
84 "Cannot perform comparison operation on arrays of different length".to_string(),
85 ));
86 }
87
88 let num_bytes = bit_util::ceil(left_len, 8);
89
90 let nulls = NullBuffer::union(left.nulls(), right.nulls());
91 let mut bool_buf = MutableBuffer::from_len_zeroed(num_bytes);
92 let bool_slice = &mut bool_buf;
93
94 for i in 0..left_len {
95 if nulls.as_ref().map(|n| n.is_valid(i)).unwrap_or(true) {
97 let list = right.value(i);
98 let list = list.as_string::<OffsetSize>();
99
100 for j in 0..list.len() {
101 if list.is_valid(j) && (left.value(i) == list.value(j)) {
102 bit_util::set_bit(bool_slice, i);
103 continue;
104 }
105 }
106 }
107 }
108 let values = BooleanBuffer::new(bool_buf.into(), 0, left_len);
109 Ok(BooleanArray::new(values, None))
110}
111
112#[rustfmt::skip::macros(vec)]
114#[cfg(test)]
115mod tests {
116 use std::sync::Arc;
117
118 use arrow_array::builder::{
119 ListBuilder, PrimitiveDictionaryBuilder, StringBuilder, StringDictionaryBuilder,
120 };
121 use arrow_array::types::*;
122 use arrow_buffer::{i256, ArrowNativeType, Buffer, IntervalDayTime, IntervalMonthDayNano};
123 use arrow_data::ArrayData;
124 use arrow_schema::{DataType, Field};
125 use half::f16;
126
127 use super::*;
128
129 macro_rules! cmp_vec {
135 ($KERNEL:path, $ARRAY:ident, $A_VEC:expr, $B_VEC:expr, $EXPECTED:expr) => {
136 let a = $ARRAY::from($A_VEC);
137 let b = $ARRAY::from($B_VEC);
138 let c = $KERNEL(&a, &b).unwrap();
139 assert_eq!(BooleanArray::from($EXPECTED), c);
140
141 let a = a.slice(0, a.len());
143 let b = b.slice(0, b.len());
144 let c = $KERNEL(&a, &b).unwrap();
145 assert_eq!(BooleanArray::from($EXPECTED), c);
146
147 let mut a = vec![];
149 let mut b = vec![];
150 let mut e = vec![];
151 for _i in 0..10 {
152 a.extend($A_VEC);
153 b.extend($B_VEC);
154 e.extend($EXPECTED);
155 }
156 let a = $ARRAY::from(a);
157 let b = $ARRAY::from(b);
158 let c = $KERNEL(&a, &b).unwrap();
159 assert_eq!(BooleanArray::from(e), c);
160 };
161 }
162
163 macro_rules! cmp_i64 {
168 ($KERNEL:path, $A_VEC:expr, $B_VEC:expr, $EXPECTED:expr) => {
169 cmp_vec!($KERNEL, Int64Array, $A_VEC, $B_VEC, $EXPECTED);
170 };
171 }
172
173 macro_rules! cmp_i64_scalar {
178 ($KERNEL:path, $A_VEC:expr, $B:literal, $EXPECTED:expr) => {
179 let a = Int64Array::from($A_VEC);
180 let b = Int64Array::new_scalar($B);
181 let c = $KERNEL(&a, &b).unwrap();
182 assert_eq!(BooleanArray::from($EXPECTED), c);
183
184 let mut a = vec![];
186 let mut e = vec![];
187 for _i in 0..10 {
188 a.extend($A_VEC);
189 e.extend($EXPECTED);
190 }
191 let a = Int64Array::from(a);
192 let c = $KERNEL(&a, &b).unwrap();
193 assert_eq!(BooleanArray::from(e), c);
194
195 };
196 }
197
198 #[test]
199 fn test_primitive_array_eq() {
200 cmp_i64!(
201 crate::cmp::eq,
202 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
203 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
204 vec![false, false, true, false, false, false, false, true, false, false]
205 );
206
207 cmp_vec!(
208 crate::cmp::eq,
209 TimestampSecondArray,
210 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
211 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
212 vec![false, false, true, false, false, false, false, true, false, false]
213 );
214
215 cmp_vec!(
216 crate::cmp::eq,
217 Time32SecondArray,
218 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
219 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
220 vec![false, false, true, false, false, false, false, true, false, false]
221 );
222
223 cmp_vec!(
224 crate::cmp::eq,
225 Time32MillisecondArray,
226 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
227 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
228 vec![false, false, true, false, false, false, false, true, false, false]
229 );
230
231 cmp_vec!(
232 crate::cmp::eq,
233 Time64MicrosecondArray,
234 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
235 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
236 vec![false, false, true, false, false, false, false, true, false, false]
237 );
238
239 cmp_vec!(
240 crate::cmp::eq,
241 Time64NanosecondArray,
242 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
243 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
244 vec![false, false, true, false, false, false, false, true, false, false]
245 );
246
247 cmp_vec!(
248 crate::cmp::eq,
249 IntervalYearMonthArray,
250 vec![
251 IntervalYearMonthType::make_value(1, 2),
252 IntervalYearMonthType::make_value(2, 1),
253 IntervalYearMonthType::make_value(1, 0),
255 ],
256 vec![
257 IntervalYearMonthType::make_value(1, 2),
258 IntervalYearMonthType::make_value(1, 2),
259 IntervalYearMonthType::make_value(0, 12),
262 ],
263 vec![true, false, true]
264 );
265
266 cmp_vec!(
267 crate::cmp::eq,
268 IntervalMonthDayNanoArray,
269 vec![
270 IntervalMonthDayNanoType::make_value(1, 2, 3),
271 IntervalMonthDayNanoType::make_value(3, 2, 1),
272 IntervalMonthDayNanoType::make_value(1, 0, 0),
274 IntervalMonthDayNanoType::make_value(1, 0, 0),
275 ],
276 vec![
277 IntervalMonthDayNanoType::make_value(1, 2, 3),
278 IntervalMonthDayNanoType::make_value(1, 2, 3),
279 IntervalMonthDayNanoType::make_value(0, 30, 0),
281 IntervalMonthDayNanoType::make_value(0, 100, 0),
283 ],
284 vec![true, false, false, false]
285 );
286 }
287
288 #[test]
289 fn test_primitive_array_eq_scalar() {
290 cmp_i64_scalar!(
291 crate::cmp::eq,
292 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
293 8,
294 vec![false, false, true, false, false, false, false, true, false, false]
295 );
296 }
297
298 #[test]
299 fn test_primitive_array_eq_with_slice() {
300 let a = Int32Array::from(vec![6, 7, 8, 8, 10]);
301 let b = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
302 let b_slice = b.slice(5, 5);
303 let d = crate::cmp::eq(&b_slice, &a).unwrap();
304 assert!(d.value(0));
305 assert!(d.value(1));
306 assert!(d.value(2));
307 assert!(!d.value(3));
308 assert!(d.value(4));
309 }
310
311 #[test]
312 fn test_primitive_array_eq_scalar_with_slice() {
313 let a = Int32Array::from(vec![Some(1), None, Some(2), Some(3)]);
314 let a = a.slice(1, 3);
315 let a_eq = crate::cmp::eq(&a, &Int32Array::new_scalar(2)).unwrap();
316 assert_eq!(
317 a_eq,
318 BooleanArray::from(vec![None, Some(true), Some(false)])
319 );
320 }
321
322 #[test]
323 fn test_primitive_array_neq() {
324 cmp_i64!(
325 crate::cmp::neq,
326 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
327 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
328 vec![true, true, false, true, true, true, true, false, true, true]
329 );
330
331 cmp_vec!(
332 crate::cmp::neq,
333 TimestampMillisecondArray,
334 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
335 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
336 vec![true, true, false, true, true, true, true, false, true, true]
337 );
338 }
339
340 #[test]
341 fn test_primitive_array_neq_scalar() {
342 cmp_i64_scalar!(
343 crate::cmp::neq,
344 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
345 8,
346 vec![true, true, false, true, true, true, true, false, true, true]
347 );
348 }
349
350 #[test]
351 fn test_boolean_array_eq() {
352 let a: BooleanArray =
353 vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
354 let b: BooleanArray =
355 vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
356
357 let res: Vec<Option<bool>> = crate::cmp::eq(&a, &b).unwrap().iter().collect();
358
359 assert_eq!(
360 res,
361 vec![Some(true), Some(false), Some(true), Some(false), None, None]
362 )
363 }
364
365 #[test]
366 fn test_boolean_array_neq() {
367 let a: BooleanArray =
368 vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
369 let b: BooleanArray =
370 vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
371
372 let res: Vec<Option<bool>> = crate::cmp::neq(&a, &b).unwrap().iter().collect();
373
374 assert_eq!(
375 res,
376 vec![Some(false), Some(true), Some(false), Some(true), None, None]
377 )
378 }
379
380 #[test]
381 fn test_boolean_array_lt() {
382 let a: BooleanArray =
383 vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
384 let b: BooleanArray =
385 vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
386
387 let res: Vec<Option<bool>> = crate::cmp::lt(&a, &b).unwrap().iter().collect();
388
389 assert_eq!(
390 res,
391 vec![Some(false), Some(true), Some(false), Some(false), None, None]
392 )
393 }
394
395 #[test]
396 fn test_boolean_array_lt_eq() {
397 let a: BooleanArray =
398 vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
399 let b: BooleanArray =
400 vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
401
402 let res: Vec<Option<bool>> = crate::cmp::lt_eq(&a, &b).unwrap().iter().collect();
403
404 assert_eq!(
405 res,
406 vec![Some(true), Some(true), Some(true), Some(false), None, None]
407 )
408 }
409
410 #[test]
411 fn test_boolean_array_gt() {
412 let a: BooleanArray =
413 vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
414 let b: BooleanArray =
415 vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
416
417 let res: Vec<Option<bool>> = crate::cmp::gt(&a, &b).unwrap().iter().collect();
418
419 assert_eq!(
420 res,
421 vec![Some(false), Some(false), Some(false), Some(true), None, None]
422 )
423 }
424
425 #[test]
426 fn test_boolean_array_gt_eq() {
427 let a: BooleanArray =
428 vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
429 let b: BooleanArray =
430 vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
431
432 let res: Vec<Option<bool>> = crate::cmp::gt_eq(&a, &b).unwrap().iter().collect();
433
434 assert_eq!(
435 res,
436 vec![Some(true), Some(false), Some(true), Some(true), None, None]
437 )
438 }
439
440 #[test]
441 fn test_boolean_array_eq_scalar() {
442 let a: BooleanArray = vec![Some(true), Some(false), None].into();
443 let b = BooleanArray::new_scalar(false);
444 let res1: Vec<Option<bool>> = crate::cmp::eq(&a, &b).unwrap().iter().collect();
445
446 assert_eq!(res1, vec![Some(false), Some(true), None]);
447 let b = BooleanArray::new_scalar(true);
448 let res2: Vec<Option<bool>> = crate::cmp::eq(&a, &b).unwrap().iter().collect();
449
450 assert_eq!(res2, vec![Some(true), Some(false), None]);
451 }
452
453 #[test]
454 fn test_boolean_array_neq_scalar() {
455 let a: BooleanArray = vec![Some(true), Some(false), None].into();
456 let b = BooleanArray::new_scalar(false);
457
458 let res1: Vec<Option<bool>> = crate::cmp::neq(&a, &b).unwrap().iter().collect();
459
460 assert_eq!(res1, vec![Some(true), Some(false), None]);
461 let b = BooleanArray::new_scalar(true);
462 let res2: Vec<Option<bool>> = crate::cmp::neq(&a, &b).unwrap().iter().collect();
463
464 assert_eq!(res2, vec![Some(false), Some(true), None]);
465 }
466
467 #[test]
468 fn test_boolean_array_lt_scalar() {
469 let a: BooleanArray = vec![Some(true), Some(false), None].into();
470 let b = BooleanArray::new_scalar(false);
471
472 let res1: Vec<Option<bool>> = crate::cmp::lt(&a, &b).unwrap().iter().collect();
473
474 assert_eq!(res1, vec![Some(false), Some(false), None]);
475
476 let b = BooleanArray::new_scalar(true);
477 let res2: Vec<Option<bool>> = crate::cmp::lt(&a, &b).unwrap().iter().collect();
478
479 assert_eq!(res2, vec![Some(false), Some(true), None]);
480 }
481
482 #[test]
483 fn test_boolean_array_lt_eq_scalar() {
484 let a: BooleanArray = vec![Some(true), Some(false), None].into();
485 let b = BooleanArray::new_scalar(false);
486 let res1: Vec<Option<bool>> = crate::cmp::lt_eq(&a, &b).unwrap().iter().collect();
487
488 assert_eq!(res1, vec![Some(false), Some(true), None]);
489
490 let b = BooleanArray::new_scalar(true);
491 let res2: Vec<Option<bool>> = crate::cmp::lt_eq(&a, &b).unwrap().iter().collect();
492
493 assert_eq!(res2, vec![Some(true), Some(true), None]);
494 }
495
496 #[test]
497 fn test_boolean_array_gt_scalar() {
498 let a: BooleanArray = vec![Some(true), Some(false), None].into();
499 let b = BooleanArray::new_scalar(false);
500 let res1: Vec<Option<bool>> = crate::cmp::gt(&a, &b).unwrap().iter().collect();
501
502 assert_eq!(res1, vec![Some(true), Some(false), None]);
503 let b = BooleanArray::new_scalar(true);
504 let res2: Vec<Option<bool>> = crate::cmp::gt(&a, &b).unwrap().iter().collect();
505
506 assert_eq!(res2, vec![Some(false), Some(false), None]);
507 }
508
509 #[test]
510 fn test_boolean_array_gt_eq_scalar() {
511 let a: BooleanArray = vec![Some(true), Some(false), None].into();
512
513 let b = BooleanArray::new_scalar(false);
514 let res1: Vec<Option<bool>> = crate::cmp::gt_eq(&a, &b).unwrap().iter().collect();
515
516 assert_eq!(res1, vec![Some(true), Some(true), None]);
517 let b = BooleanArray::new_scalar(true);
518 let res2: Vec<Option<bool>> = crate::cmp::gt_eq(&a, &b).unwrap().iter().collect();
519
520 assert_eq!(res2, vec![Some(true), Some(false), None]);
521 }
522
523 #[test]
524 fn test_primitive_array_lt() {
525 cmp_i64!(
526 crate::cmp::lt,
527 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
528 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
529 vec![false, false, false, true, true, false, false, false, true, true]
530 );
531
532 cmp_vec!(
533 crate::cmp::lt,
534 TimestampMillisecondArray,
535 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
536 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
537 vec![false, false, false, true, true, false, false, false, true, true]
538 );
539
540 cmp_vec!(
541 crate::cmp::lt,
542 IntervalDayTimeArray,
543 vec![
544 IntervalDayTimeType::make_value(1, 0),
545 IntervalDayTimeType::make_value(0, 1000),
546 IntervalDayTimeType::make_value(1, 1000),
547 IntervalDayTimeType::make_value(1, 3000),
548 IntervalDayTimeType::make_value(0, 90_000_000),
550 ],
551 vec![
552 IntervalDayTimeType::make_value(0, 1000),
553 IntervalDayTimeType::make_value(1, 0),
554 IntervalDayTimeType::make_value(10, 0),
555 IntervalDayTimeType::make_value(2, 1),
556 IntervalDayTimeType::make_value(0, 12),
560 ],
561 vec![false, true, true, true ,false]
562 );
563
564 cmp_vec!(
565 crate::cmp::lt,
566 IntervalYearMonthArray,
567 vec![
568 IntervalYearMonthType::make_value(1, 2),
569 IntervalYearMonthType::make_value(2, 1),
570 IntervalYearMonthType::make_value(1, 2),
571 IntervalYearMonthType::make_value(1, 0),
573 ],
574 vec![
575 IntervalYearMonthType::make_value(1, 2),
576 IntervalYearMonthType::make_value(1, 2),
577 IntervalYearMonthType::make_value(2, 1),
578 IntervalYearMonthType::make_value(0, 12),
581 ],
582 vec![false, false, true, false]
583 );
584
585 cmp_vec!(
586 crate::cmp::lt,
587 IntervalMonthDayNanoArray,
588 vec![
589 IntervalMonthDayNanoType::make_value(1, 2, 3),
590 IntervalMonthDayNanoType::make_value(3, 2, 1),
591 IntervalMonthDayNanoType::make_value(1, 0, 0),
593 IntervalMonthDayNanoType::make_value(1, 2, 0),
594 IntervalMonthDayNanoType::make_value(1, 0, 0),
595 ],
596 vec![
597 IntervalMonthDayNanoType::make_value(1, 2, 3),
598 IntervalMonthDayNanoType::make_value(1, 2, 3),
599 IntervalMonthDayNanoType::make_value(2, 0, 0),
600 IntervalMonthDayNanoType::make_value(0, 30, 0),
602 IntervalMonthDayNanoType::make_value(0, 100, 0),
604 ],
605 vec![false, false, true, false, false]
606 );
607 }
608
609 #[test]
610 fn test_primitive_array_lt_scalar() {
611 cmp_i64_scalar!(
612 crate::cmp::lt,
613 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
614 8,
615 vec![true, true, false, false, false, true, true, false, false, false]
616 );
617 }
618
619 #[test]
620 fn test_primitive_array_lt_nulls() {
621 cmp_i64!(
622 crate::cmp::lt,
623 vec![None, None, Some(1), Some(1), None, None, Some(2), Some(2),],
624 vec![None, Some(1), None, Some(1), None, Some(3), None, Some(3),],
625 vec![None, None, None, Some(false), None, None, None, Some(true)]
626 );
627
628 cmp_vec!(
629 crate::cmp::lt,
630 TimestampMillisecondArray,
631 vec![None, None, Some(1), Some(1), None, None, Some(2), Some(2),],
632 vec![None, Some(1), None, Some(1), None, Some(3), None, Some(3),],
633 vec![None, None, None, Some(false), None, None, None, Some(true)]
634 );
635 }
636
637 #[test]
638 fn test_primitive_array_lt_scalar_nulls() {
639 cmp_i64_scalar!(
640 crate::cmp::lt,
641 vec![None, Some(1), Some(2), Some(3), None, Some(1), Some(2), Some(3), Some(2), None],
642 2,
643 vec![None, Some(true), Some(false), Some(false), None, Some(true), Some(false), Some(false), Some(false), None]
644 );
645 }
646
647 #[test]
648 fn test_primitive_array_lt_eq() {
649 cmp_i64!(
650 crate::cmp::lt_eq,
651 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
652 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
653 vec![false, false, true, true, true, false, false, true, true, true]
654 );
655 }
656
657 #[test]
658 fn test_primitive_array_lt_eq_scalar() {
659 cmp_i64_scalar!(
660 crate::cmp::lt_eq,
661 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
662 8,
663 vec![true, true, true, false, false, true, true, true, false, false]
664 );
665 }
666
667 #[test]
668 fn test_primitive_array_lt_eq_nulls() {
669 cmp_i64!(
670 crate::cmp::lt_eq,
671 vec![None, None, Some(1), None, None, Some(1), None, None, Some(1)],
672 vec![None, Some(1), Some(0), None, Some(1), Some(2), None, None, Some(3)],
673 vec![None, None, Some(false), None, None, Some(true), None, None, Some(true)]
674 );
675 }
676
677 #[test]
678 fn test_primitive_array_lt_eq_scalar_nulls() {
679 cmp_i64_scalar!(
680 crate::cmp::lt_eq,
681 vec![None, Some(1), Some(2), None, Some(1), Some(2), None, Some(1), Some(2)],
682 1,
683 vec![None, Some(true), Some(false), None, Some(true), Some(false), None, Some(true), Some(false)]
684 );
685 }
686
687 #[test]
688 fn test_primitive_array_gt() {
689 cmp_i64!(
690 crate::cmp::gt,
691 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
692 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
693 vec![true, true, false, false, false, true, true, false, false, false]
694 );
695 }
696
697 #[test]
698 fn test_primitive_array_gt_scalar() {
699 cmp_i64_scalar!(
700 crate::cmp::gt,
701 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
702 8,
703 vec![false, false, false, true, true, false, false, false, true, true]
704 );
705 }
706
707 #[test]
708 fn test_primitive_array_gt_nulls() {
709 cmp_i64!(
710 crate::cmp::gt,
711 vec![None, None, Some(1), None, None, Some(2), None, None, Some(3)],
712 vec![None, Some(1), Some(1), None, Some(1), Some(1), None, Some(1), Some(1)],
713 vec![None, None, Some(false), None, None, Some(true), None, None, Some(true)]
714 );
715 }
716
717 #[test]
718 fn test_primitive_array_gt_scalar_nulls() {
719 cmp_i64_scalar!(
720 crate::cmp::gt,
721 vec![None, Some(1), Some(2), None, Some(1), Some(2), None, Some(1), Some(2)],
722 1,
723 vec![None, Some(false), Some(true), None, Some(false), Some(true), None, Some(false), Some(true)]
724 );
725 }
726
727 #[test]
728 fn test_primitive_array_gt_eq() {
729 cmp_i64!(
730 crate::cmp::gt_eq,
731 vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
732 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
733 vec![true, true, true, false, false, true, true, true, false, false]
734 );
735 }
736
737 #[test]
738 fn test_primitive_array_gt_eq_scalar() {
739 cmp_i64_scalar!(
740 crate::cmp::gt_eq,
741 vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
742 8,
743 vec![false, false, true, true, true, false, false, true, true, true]
744 );
745 }
746
747 #[test]
748 fn test_primitive_array_gt_eq_nulls() {
749 cmp_i64!(
750 crate::cmp::gt_eq,
751 vec![None, None, Some(1), None, Some(1), Some(2), None, None, Some(1)],
752 vec![None, Some(1), None, None, Some(1), Some(1), None, Some(2), Some(2)],
753 vec![None, None, None, None, Some(true), Some(true), None, None, Some(false)]
754 );
755 }
756
757 #[test]
758 fn test_primitive_array_gt_eq_scalar_nulls() {
759 cmp_i64_scalar!(
760 crate::cmp::gt_eq,
761 vec![None, Some(1), Some(2), None, Some(2), Some(3), None, Some(3), Some(4)],
762 2,
763 vec![None, Some(false), Some(true), None, Some(true), Some(true), None, Some(true), Some(true)]
764 );
765 }
766
767 #[test]
768 fn test_primitive_array_compare_slice() {
769 let a: Int32Array = (0..100).map(Some).collect();
770 let a = a.slice(50, 50);
771 let b: Int32Array = (100..200).map(Some).collect();
772 let b = b.slice(50, 50);
773 let actual = crate::cmp::lt(&a, &b).unwrap();
774 let expected: BooleanArray = (0..50).map(|_| Some(true)).collect();
775 assert_eq!(expected, actual);
776 }
777
778 #[test]
779 fn test_primitive_array_compare_scalar_slice() {
780 let a: Int32Array = (0..100).map(Some).collect();
781 let a = a.slice(50, 50);
782 let scalar = Int32Array::new_scalar(200);
783 let actual = crate::cmp::lt(&a, &scalar).unwrap();
784 let expected: BooleanArray = (0..50).map(|_| Some(true)).collect();
785 assert_eq!(expected, actual);
786 }
787
788 #[test]
789 fn test_length_of_result_buffer() {
790 let item_count = 130;
793
794 let select_mask: BooleanArray = vec![true; item_count].into();
795
796 let array_a: PrimitiveArray<Int8Type> = vec![1; item_count].into();
797 let array_b: PrimitiveArray<Int8Type> = vec![2; item_count].into();
798 let result_mask = crate::cmp::gt_eq(&array_a, &array_b).unwrap();
799
800 assert_eq!(result_mask.values().len(), select_mask.values().len());
801 }
802
803 #[test]
809 fn test_contains() {
810 let value_data = Int32Array::from(vec![
811 Some(0),
812 Some(1),
813 Some(2),
814 Some(3),
815 Some(4),
816 Some(5),
817 Some(6),
818 None,
819 Some(7),
820 ])
821 .into_data();
822 let value_offsets = Buffer::from_slice_ref([0i64, 3, 6, 6, 9]);
823 let list_data_type =
824 DataType::LargeList(Arc::new(Field::new_list_field(DataType::Int32, true)));
825 let list_data = ArrayData::builder(list_data_type)
826 .len(4)
827 .add_buffer(value_offsets)
828 .add_child_data(value_data)
829 .null_bit_buffer(Some(Buffer::from([0b00001011])))
830 .build()
831 .unwrap();
832
833 let list_array = LargeListArray::from(list_data);
835
836 let nulls = Int32Array::from(vec![None, None, None, None]);
837 let nulls_result = in_list(&nulls, &list_array).unwrap();
838 assert_eq!(
839 nulls_result
840 .as_any()
841 .downcast_ref::<BooleanArray>()
842 .unwrap(),
843 &BooleanArray::from(vec![false, false, false, false]),
844 );
845
846 let values = Int32Array::from(vec![Some(0), Some(0), Some(0), Some(0)]);
847 let values_result = in_list(&values, &list_array).unwrap();
848 assert_eq!(
849 values_result
850 .as_any()
851 .downcast_ref::<BooleanArray>()
852 .unwrap(),
853 &BooleanArray::from(vec![true, false, false, false]),
854 );
855 }
856
857 #[test]
858 fn test_interval_array() {
859 let a = IntervalDayTimeArray::from(vec![
860 Some(IntervalDayTime::new(0, 1)),
861 Some(IntervalDayTime::new(0, 6)),
862 Some(IntervalDayTime::new(4, 834)),
863 None,
864 Some(IntervalDayTime::new(2, 3)),
865 None
866 ]);
867 let b = IntervalDayTimeArray::from(vec![
868 Some(IntervalDayTime::new(0, 4)),
869 Some(IntervalDayTime::new(0, 6)),
870 Some(IntervalDayTime::new(0, 834)),
871 None,
872 Some(IntervalDayTime::new(2, 3)),
873 None
874 ]);
875 let res = crate::cmp::eq(&a, &b).unwrap();
876 assert_eq!(
877 &res,
878 &BooleanArray::from(vec![Some(false), Some(true), Some(false), None, Some(true), None])
879 );
880
881 let a = IntervalMonthDayNanoArray::from(vec![
882 Some(IntervalMonthDayNano::new(0, 0, 6)),
883 Some(IntervalMonthDayNano::new(2, 0, 0)),
884 Some(IntervalMonthDayNano::new(2, -5, 0)),
885 None,
886 Some(IntervalMonthDayNano::new(0, 0, 2)),
887 Some(IntervalMonthDayNano::new(5, 0, -23)),
888 ]);
889 let b = IntervalMonthDayNanoArray::from(vec![
890 Some(IntervalMonthDayNano::new(0, 0, 6)),
891 Some(IntervalMonthDayNano::new(2, 3, 0)),
892 Some(IntervalMonthDayNano::new(5, -5, 0)),
893 None,
894 Some(IntervalMonthDayNano::new(-1, 0, 2)),
895 None,
896 ]);
897 let res = crate::cmp::lt(&a, &b).unwrap();
898 assert_eq!(
899 &res,
900 &BooleanArray::from(vec![Some(false), Some(true), Some(true), None, Some(false), None])
901 );
902
903 let a =
904 IntervalYearMonthArray::from(vec![Some(0), Some(623), Some(834), None, Some(3), None]);
905 let b = IntervalYearMonthArray::from(
906 vec![Some(86), Some(5), Some(834), Some(6), Some(86), None],
907 );
908 let res = crate::cmp::gt_eq(&a, &b).unwrap();
909 assert_eq!(
910 &res,
911 &BooleanArray::from(vec![Some(false), Some(true), Some(true), None, Some(false), None])
912 );
913 }
914
915 macro_rules! test_binary {
916 ($test_name:ident, $left:expr, $right:expr, $op:path, $expected:expr) => {
917 #[test]
918 fn $test_name() {
919 let expected = BooleanArray::from($expected);
920
921 let left = BinaryArray::from_vec($left);
922 let right = BinaryArray::from_vec($right);
923 let res = $op(&left, &right).unwrap();
924 assert_eq!(res, expected);
925
926 let left = LargeBinaryArray::from_vec($left);
927 let right = LargeBinaryArray::from_vec($right);
928 let res = $op(&left, &right).unwrap();
929 assert_eq!(res, expected);
930 }
931 };
932 }
933
934 #[test]
935 fn test_binary_eq_scalar_on_slice() {
936 let a = BinaryArray::from_opt_vec(vec![Some(b"hi"), None, Some(b"hello"), Some(b"world")]);
937 let a = a.slice(1, 3);
938 let a = as_generic_binary_array::<i32>(&a);
939 let b = BinaryArray::new_scalar(b"hello");
940 let a_eq = crate::cmp::eq(a, &b).unwrap();
941 assert_eq!(
942 a_eq,
943 BooleanArray::from(vec![None, Some(true), Some(false)])
944 );
945 }
946
947 macro_rules! test_binary_scalar {
948 ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
949 #[test]
950 fn $test_name() {
951 let expected = BooleanArray::from($expected);
952
953 let left = BinaryArray::from_vec($left);
954 let right = BinaryArray::new_scalar($right);
955 let res = $op(&left, &right).unwrap();
956 assert_eq!(res, expected);
957
958 let left = LargeBinaryArray::from_vec($left);
959 let right = LargeBinaryArray::new_scalar($right);
960 let res = $op(&left, &right).unwrap();
961 assert_eq!(res, expected);
962 }
963 };
964 }
965
966 test_binary!(
967 test_binary_array_eq,
968 vec![b"arrow", b"arrow", b"arrow", b"arrow", &[0xff, 0xf8]],
969 vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
970 crate::cmp::eq,
971 vec![true, false, false, false, true]
972 );
973
974 test_binary_scalar!(
975 test_binary_array_eq_scalar,
976 vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
977 "arrow".as_bytes(),
978 crate::cmp::eq,
979 vec![true, false, false, false, false]
980 );
981
982 test_binary!(
983 test_binary_array_neq,
984 vec![b"arrow", b"arrow", b"arrow", b"arrow", &[0xff, 0xf8]],
985 vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf9]],
986 crate::cmp::neq,
987 vec![false, true, true, true, true]
988 );
989 test_binary_scalar!(
990 test_binary_array_neq_scalar,
991 vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
992 "arrow".as_bytes(),
993 crate::cmp::neq,
994 vec![false, true, true, true, true]
995 );
996
997 test_binary!(
998 test_binary_array_lt,
999 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
1000 vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf9]],
1001 crate::cmp::lt,
1002 vec![true, true, false, false, true]
1003 );
1004 test_binary_scalar!(
1005 test_binary_array_lt_scalar,
1006 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
1007 "flight".as_bytes(),
1008 crate::cmp::lt,
1009 vec![true, true, false, false, false]
1010 );
1011
1012 test_binary!(
1013 test_binary_array_lt_eq,
1014 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
1015 vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8, 0xf9]],
1016 crate::cmp::lt_eq,
1017 vec![true, true, true, false, true]
1018 );
1019 test_binary_scalar!(
1020 test_binary_array_lt_eq_scalar,
1021 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
1022 "flight".as_bytes(),
1023 crate::cmp::lt_eq,
1024 vec![true, true, true, false, false]
1025 );
1026
1027 test_binary!(
1028 test_binary_array_gt,
1029 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf9]],
1030 vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8]],
1031 crate::cmp::gt,
1032 vec![false, false, false, true, true]
1033 );
1034 test_binary_scalar!(
1035 test_binary_array_gt_scalar,
1036 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
1037 "flight".as_bytes(),
1038 crate::cmp::gt,
1039 vec![false, false, false, true, true]
1040 );
1041
1042 test_binary!(
1043 test_binary_array_gt_eq,
1044 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
1045 vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8]],
1046 crate::cmp::gt_eq,
1047 vec![false, false, true, true, true]
1048 );
1049 test_binary_scalar!(
1050 test_binary_array_gt_eq_scalar,
1051 vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
1052 "flight".as_bytes(),
1053 crate::cmp::gt_eq,
1054 vec![false, false, true, true, true]
1055 );
1056
1057 #[test]
1063 fn test_contains_utf8() {
1064 let values_builder = StringBuilder::new();
1065 let mut builder = ListBuilder::new(values_builder);
1066
1067 builder.values().append_value("Lorem");
1068 builder.values().append_value("ipsum");
1069 builder.values().append_null();
1070 builder.append(true);
1071 builder.values().append_value("sit");
1072 builder.values().append_value("amet");
1073 builder.values().append_value("Lorem");
1074 builder.append(true);
1075 builder.append(false);
1076 builder.values().append_value("ipsum");
1077 builder.append(true);
1078
1079 let list_array = builder.finish();
1082
1083 let v: Vec<Option<&str>> = vec![None, None, None, None];
1084 let nulls = StringArray::from(v);
1085 let nulls_result = in_list_utf8(&nulls, &list_array).unwrap();
1086 assert_eq!(
1087 nulls_result
1088 .as_any()
1089 .downcast_ref::<BooleanArray>()
1090 .unwrap(),
1091 &BooleanArray::from(vec![false, false, false, false]),
1092 );
1093
1094 let values = StringArray::from(vec![
1095 Some("Lorem"),
1096 Some("Lorem"),
1097 Some("Lorem"),
1098 Some("Lorem"),
1099 ]);
1100 let values_result = in_list_utf8(&values, &list_array).unwrap();
1101 assert_eq!(
1102 values_result
1103 .as_any()
1104 .downcast_ref::<BooleanArray>()
1105 .unwrap(),
1106 &BooleanArray::from(vec![true, true, false, false]),
1107 );
1108 }
1109
1110 macro_rules! test_utf8 {
1111 ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
1112 #[test]
1113 fn $test_name() {
1114 let left = StringArray::from($left);
1115 let right = StringArray::from($right);
1116 let res = $op(&left, &right).unwrap();
1117 let expected = $expected;
1118 assert_eq!(expected.len(), res.len());
1119 for i in 0..res.len() {
1120 let v = res.value(i);
1121 assert_eq!(v, expected[i]);
1122 }
1123 }
1124 };
1125 }
1126
1127 macro_rules! test_utf8_view {
1128 ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
1129 #[test]
1130 fn $test_name() {
1131 let left = StringViewArray::from_iter_values($left);
1132 let right = StringViewArray::from_iter_values($right);
1133 let res = $op(&left, &right).unwrap();
1134 let expected = $expected;
1135 assert_eq!(expected.len(), res.len());
1136 for i in 0..res.len() {
1137 let v = res.value(i);
1138 assert_eq!(v, expected[i]);
1139 }
1140 }
1141 };
1142 }
1143
1144 #[test]
1145 fn test_utf8_eq_scalar_on_slice() {
1146 let a = StringArray::from(vec![Some("hi"), None, Some("hello"), Some("world"), Some("")]);
1147 let a = a.slice(1, 4);
1148 let scalar = StringArray::new_scalar("hello");
1149 let a_eq = crate::cmp::eq(&a, &scalar).unwrap();
1150 assert_eq!(
1151 a_eq,
1152 BooleanArray::from(vec![None, Some(true), Some(false), Some(false)])
1153 );
1154
1155 let scalar = StringArray::new_scalar("");
1156 let a_eq2 = crate::cmp::eq(&a, &scalar).unwrap();
1157
1158 assert_eq!(
1159 a_eq2,
1160 BooleanArray::from(vec![None, Some(false), Some(false), Some(true)])
1161 );
1162 }
1163
1164 macro_rules! test_utf8_scalar {
1165 ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
1166 #[test]
1167 fn $test_name() {
1168 let left = StringArray::from($left);
1169 let right = StringArray::new_scalar($right);
1170 let res = $op(&left, &right).unwrap();
1171 let expected = $expected;
1172 assert_eq!(expected.len(), res.len());
1173 for i in 0..res.len() {
1174 let v = res.value(i);
1175 assert_eq!(
1176 v,
1177 expected[i],
1178 "unexpected result when comparing {} at position {} to {} ",
1179 left.value(i),
1180 i,
1181 $right
1182 );
1183 }
1184
1185 let left = LargeStringArray::from($left);
1186 let right = LargeStringArray::new_scalar($right);
1187 let res = $op(&left, &right).unwrap();
1188 let expected = $expected;
1189 assert_eq!(expected.len(), res.len());
1190 for i in 0..res.len() {
1191 let v = res.value(i);
1192 assert_eq!(
1193 v,
1194 expected[i],
1195 "unexpected result when comparing {} at position {} to {} ",
1196 left.value(i),
1197 i,
1198 $right
1199 );
1200 }
1201 }
1202 };
1203 ($test_name:ident, $test_name_dyn:ident, $left:expr, $right:expr, $op:expr, $op_dyn:expr, $expected:expr) => {
1204 test_utf8_scalar!($test_name, $left, $right, $op, $expected);
1205 test_utf8_scalar!($test_name_dyn, $left, $right, $op_dyn, $expected);
1206 };
1207 }
1208
1209 macro_rules! test_utf8_view_scalar {
1210 ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
1211 #[test]
1212 fn $test_name() {
1213 let left = StringViewArray::from_iter_values($left);
1214 let right = StringViewArray::new_scalar($right);
1215 let res = $op(&left, &right).unwrap();
1216 let expected = $expected;
1217 assert_eq!(expected.len(), res.len());
1218 for i in 0..res.len() {
1219 let v = res.value(i);
1220 assert_eq!(
1221 v,
1222 expected[i],
1223 "unexpected result when comparing {} at position {} to {} ",
1224 left.value(i),
1225 i,
1226 $right
1227 );
1228 }
1229 }
1230 };
1231 }
1232
1233 const LARGE_1: &str = "prefix-larger than 12 bytes string";
1234 const LARGE_2: &str = "prefix-larger but different string";
1235 const SMALL_1: &str = "pref1";
1236 const SMALL_2: &str = "pref2";
1237 const TEST_ARRAY_1: [&str; 5] = [LARGE_1, LARGE_1, SMALL_1, SMALL_1, LARGE_1];
1242 const TEST_ARRAY_2: [&str; 5] = [LARGE_1, LARGE_2, SMALL_1, SMALL_2, SMALL_1];
1243
1244 test_utf8!(
1245 test_utf8_array_eq,
1246 vec!["arrow", "arrow", "arrow", "arrow"],
1247 vec!["arrow", "parquet", "datafusion", "flight"],
1248 crate::cmp::eq,
1249 [true, false, false, false]
1250 );
1251 test_utf8_view!(
1252 test_utf8_view_array_eq,
1253 TEST_ARRAY_1,
1254 TEST_ARRAY_2,
1255 crate::cmp::eq,
1256 [true, false, true, false, false]
1257 );
1258 test_utf8_scalar!(
1259 test_utf8_array_eq_scalar,
1260 vec!["arrow", "parquet", "datafusion", "flight"],
1261 "arrow",
1262 crate::cmp::eq,
1263 [true, false, false, false]
1264 );
1265 test_utf8_view_scalar!(
1266 test_utf8_view_array_eq_large_scalar,
1267 TEST_ARRAY_2,
1268 LARGE_1,
1269 crate::cmp::eq,
1270 [true, false, false, false, false]
1271 );
1272 test_utf8_view_scalar!(
1273 test_utf8_view_array_eq_small_scalar,
1274 TEST_ARRAY_2,
1275 SMALL_1,
1276 crate::cmp::eq,
1277 [false, false, true, false, true]
1278 );
1279
1280 test_utf8!(
1281 test_utf8_array_neq,
1282 vec!["arrow", "arrow", "arrow", "arrow"],
1283 vec!["arrow", "parquet", "datafusion", "flight"],
1284 crate::cmp::neq,
1285 [false, true, true, true]
1286 );
1287 test_utf8_view!(
1288 test_utf8_view_array_neq,
1289 TEST_ARRAY_1,
1290 TEST_ARRAY_2,
1291 crate::cmp::neq,
1292 [false, true, false, true, true]
1293 );
1294 test_utf8_scalar!(
1295 test_utf8_array_neq_scalar,
1296 vec!["arrow", "parquet", "datafusion", "flight"],
1297 "arrow",
1298 crate::cmp::neq,
1299 [false, true, true, true]
1300 );
1301 test_utf8_view_scalar!(
1302 test_utf8_view_array_neq_scalar,
1303 TEST_ARRAY_2,
1304 LARGE_1,
1305 crate::cmp::neq,
1306 [false, true, true, true, true]
1307 );
1308
1309 test_utf8!(
1310 test_utf8_array_lt,
1311 vec!["arrow", "datafusion", "flight", "parquet"],
1312 vec!["flight", "flight", "flight", "flight"],
1313 crate::cmp::lt,
1314 [true, true, false, false]
1315 );
1316 test_utf8_view!(
1317 test_utf8_view_array_lt,
1318 TEST_ARRAY_1,
1319 TEST_ARRAY_2,
1320 crate::cmp::lt,
1321 [false, false, false, true, false]
1322 );
1323 test_utf8_scalar!(
1324 test_utf8_array_lt_scalar,
1325 vec!["arrow", "datafusion", "flight", "parquet"],
1326 "flight",
1327 crate::cmp::lt,
1328 [true, true, false, false]
1329 );
1330 test_utf8_view_scalar!(
1331 test_utf8_view_array_lt_scalar,
1332 TEST_ARRAY_2,
1333 LARGE_1,
1334 crate::cmp::lt,
1335 [false, true, true, true, true]
1336 );
1337 test_utf8_view_scalar!(
1338 test_utf8_view_array_lt_scalar_small,
1339 TEST_ARRAY_2,
1340 SMALL_1,
1341 crate::cmp::lt,
1342 [false, false, false, false, false]
1343 );
1344
1345 test_utf8!(
1346 test_utf8_array_lt_eq,
1347 vec!["arrow", "datafusion", "flight", "parquet"],
1348 vec!["flight", "flight", "flight", "flight"],
1349 crate::cmp::lt_eq,
1350 [true, true, true, false]
1351 );
1352 test_utf8_view!(
1353 test_utf8_view_array_lt_eq,
1354 TEST_ARRAY_1,
1355 TEST_ARRAY_2,
1356 crate::cmp::lt_eq,
1357 [true, false, true, true, false]
1358 );
1359 test_utf8_scalar!(
1360 test_utf8_array_lt_eq_scalar,
1361 vec!["arrow", "datafusion", "flight", "parquet"],
1362 "flight",
1363 crate::cmp::lt_eq,
1364 [true, true, true, false]
1365 );
1366 test_utf8_view_scalar!(
1367 test_utf8_view_array_lt_eq_scalar,
1368 TEST_ARRAY_2,
1369 LARGE_1,
1370 crate::cmp::lt_eq,
1371 [true, true, true, true, true]
1372 );
1373
1374 test_utf8!(
1375 test_utf8_array_gt,
1376 vec!["arrow", "datafusion", "flight", "parquet"],
1377 vec!["flight", "flight", "flight", "flight"],
1378 crate::cmp::gt,
1379 [false, false, false, true]
1380 );
1381 test_utf8_view!(
1382 test_utf8_view_array_gt,
1383 TEST_ARRAY_1,
1384 TEST_ARRAY_2,
1385 crate::cmp::gt,
1386 [false, true, false, false, true]
1387 );
1388 test_utf8_scalar!(
1389 test_utf8_array_gt_scalar,
1390 vec!["arrow", "datafusion", "flight", "parquet"],
1391 "flight",
1392 crate::cmp::gt,
1393 [false, false, false, true]
1394 );
1395 test_utf8_view_scalar!(
1396 test_utf8_view_array_gt_scalar,
1397 TEST_ARRAY_2,
1398 LARGE_1,
1399 crate::cmp::gt,
1400 [false, false, false, false, false]
1401 );
1402 test_utf8_view_scalar!(
1403 test_utf8_view_array_gt_scalar_small,
1404 TEST_ARRAY_2,
1405 SMALL_1,
1406 crate::cmp::gt,
1407 [true, true, false, true, false]
1408 );
1409
1410 test_utf8!(
1411 test_utf8_array_gt_eq,
1412 vec!["arrow", "datafusion", "flight", "parquet"],
1413 vec!["flight", "flight", "flight", "flight"],
1414 crate::cmp::gt_eq,
1415 [false, false, true, true]
1416 );
1417 test_utf8_view!(
1418 test_utf8_view_array_gt_eq,
1419 TEST_ARRAY_1,
1420 TEST_ARRAY_2,
1421 crate::cmp::gt_eq,
1422 [true, true, true, false, true]
1423 );
1424 test_utf8_scalar!(
1425 test_utf8_array_gt_eq_scalar,
1426 vec!["arrow", "datafusion", "flight", "parquet"],
1427 "flight",
1428 crate::cmp::gt_eq,
1429 [false, false, true, true]
1430 );
1431 test_utf8_view_scalar!(
1432 test_utf8_view_array_gt_eq_scalar,
1433 TEST_ARRAY_2,
1434 LARGE_1,
1435 crate::cmp::gt_eq,
1436 [true, false, false, false, false]
1437 );
1438 test_utf8_view_scalar!(
1439 test_utf8_view_array_gt_eq_scalar_small,
1440 TEST_ARRAY_2,
1441 SMALL_1,
1442 crate::cmp::gt_eq,
1443 [true, true, true, true, true]
1444 );
1445
1446 #[test]
1447 fn test_eq_dyn_scalar() {
1448 let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
1449 let b = Int32Array::new_scalar(8);
1450 let a_eq = crate::cmp::eq(&array, &b).unwrap();
1451 assert_eq!(
1452 a_eq,
1453 BooleanArray::from(vec![Some(false), Some(false), Some(true), Some(true), Some(false)])
1454 );
1455 }
1456
1457 #[test]
1458 fn test_eq_dyn_scalar_with_dict() {
1459 let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
1460 builder.append(123).unwrap();
1461 builder.append_null();
1462 builder.append(23).unwrap();
1463 let array = builder.finish();
1464 let b = DictionaryArray::<Int8Type>::new_scalar(Int32Array::new_scalar(123));
1465
1466 let a_eq = crate::cmp::eq(&array, &b).unwrap();
1467 assert_eq!(
1468 a_eq,
1469 BooleanArray::from(vec![Some(true), None, Some(false)])
1470 );
1471 }
1472
1473 #[test]
1474 fn test_eq_dyn_scalar_float() {
1475 let array = Float32Array::from(vec![6.0, 7.0, 8.0, 8.0, 10.0]);
1476 let expected =
1477 BooleanArray::from(vec![Some(false), Some(false), Some(true), Some(true), Some(false)]);
1478 let b = Float32Array::new_scalar(8.);
1479 assert_eq!(crate::cmp::eq(&array, &b).unwrap(), expected);
1480
1481 let array = array.unary::<_, Float64Type>(|x| x as f64);
1482 let b = Float64Array::new_scalar(8.);
1483 assert_eq!(crate::cmp::eq(&array, &b).unwrap(), expected);
1484 }
1485
1486 #[test]
1487 fn test_lt_dyn_scalar() {
1488 let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
1489 let b = Int32Array::new_scalar(8);
1490 let a_eq = crate::cmp::lt(&array, &b).unwrap();
1491 assert_eq!(a_eq, BooleanArray::from(vec![true, true,false,false,false]));
1492 }
1493
1494 #[test]
1495 fn test_lt_dyn_scalar_with_dict() {
1496 let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
1497 builder.append(123).unwrap();
1498 builder.append_null();
1499 builder.append(23).unwrap();
1500 let array = builder.finish();
1501 let b = DictionaryArray::<Int8Type>::new_scalar(Int32Array::new_scalar(123));
1502 let a_eq = crate::cmp::lt(&array, &b).unwrap();
1503 assert_eq!(
1504 a_eq,
1505 BooleanArray::from(vec![Some(false), None, Some(true)])
1506 );
1507 }
1508
1509 #[test]
1510 fn test_lt_dyn_scalar_float() {
1511 let array: Float32Array = Float32Array::from(vec![6.0, 7.0, 8.0, 8.0, 10.0]);
1512 let expected = BooleanArray::from(vec![true,true,false,false,false]);
1513 let b = Float32Array::new_scalar(8.);
1514
1515 assert_eq!(crate::cmp::lt(&array, &b).unwrap(), expected);
1516
1517 let array = array.unary::<_, Float64Type>(|x| x as f64);
1518 let b = Float64Array::new_scalar(8.);
1519 assert_eq!(crate::cmp::lt(&array, &b).unwrap(), expected);
1520 }
1521
1522 #[test]
1523 fn test_lt_eq_dyn_scalar() {
1524 let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
1525 let b = Int32Array::new_scalar(8);
1526 let a_eq = crate::cmp::lt_eq(&array, &b).unwrap();
1527 assert_eq!(a_eq, BooleanArray::from(vec![true,true,true,true,false]));
1528 }
1529
1530 fn test_primitive_dyn_scalar<T: ArrowPrimitiveType>(array: PrimitiveArray<T>) {
1531 let b = PrimitiveArray::<T>::new_scalar(T::Native::usize_as(8));
1532 let a_eq = crate::cmp::eq(&array, &b).unwrap();
1533 assert_eq!(
1534 a_eq,
1535 BooleanArray::from(vec![Some(false), None, Some(true), None, Some(false)])
1536 );
1537
1538 let a_eq = crate::cmp::gt_eq(&array, &b).unwrap();
1539 assert_eq!(
1540 a_eq,
1541 BooleanArray::from(vec![Some(false), None, Some(true), None, Some(true)])
1542 );
1543
1544 let a_eq = crate::cmp::gt(&array, &b).unwrap();
1545 assert_eq!(
1546 a_eq,
1547 BooleanArray::from(vec![Some(false), None, Some(false), None, Some(true)])
1548 );
1549
1550 let a_eq = crate::cmp::lt_eq(&array, &b).unwrap();
1551 assert_eq!(
1552 a_eq,
1553 BooleanArray::from(vec![Some(true), None, Some(true), None, Some(false)])
1554 );
1555
1556 let a_eq = crate::cmp::lt(&array, &b).unwrap();
1557 assert_eq!(
1558 a_eq,
1559 BooleanArray::from(vec![Some(true), None, Some(false), None, Some(false)])
1560 );
1561 }
1562
1563 #[test]
1564 fn test_timestamp_dyn_scalar() {
1565 let array = TimestampSecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1566 test_primitive_dyn_scalar(array);
1567
1568 let array = TimestampMicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1569 test_primitive_dyn_scalar(array);
1570
1571 let array = TimestampMicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1572 test_primitive_dyn_scalar(array);
1573
1574 let array = TimestampNanosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1575 test_primitive_dyn_scalar(array);
1576 }
1577
1578 #[test]
1579 fn test_date32_dyn_scalar() {
1580 let array = Date32Array::from(vec![Some(1), None, Some(8), None, Some(10)]);
1581 test_primitive_dyn_scalar(array);
1582 }
1583
1584 #[test]
1585 fn test_date64_dyn_scalar() {
1586 let array = Date64Array::from(vec![Some(1), None, Some(8), None, Some(10)]);
1587 test_primitive_dyn_scalar(array);
1588 }
1589
1590 #[test]
1591 fn test_time32_dyn_scalar() {
1592 let array = Time32SecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1593 test_primitive_dyn_scalar(array);
1594
1595 let array = Time32MillisecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1596 test_primitive_dyn_scalar(array);
1597 }
1598
1599 #[test]
1600 fn test_time64_dyn_scalar() {
1601 let array = Time64MicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1602 test_primitive_dyn_scalar(array);
1603
1604 let array = Time64NanosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1605 test_primitive_dyn_scalar(array);
1606 }
1607
1608 #[test]
1609 fn test_interval_dyn_scalar() {
1610 let array = IntervalDayTimeArray::from(vec![
1611 Some(IntervalDayTime::new(1, 0)),
1612 None,
1613 Some(IntervalDayTime::new(8, 0)),
1614 None,
1615 Some(IntervalDayTime::new(10, 0)),
1616 ]);
1617 test_primitive_dyn_scalar(array);
1618
1619 let array = IntervalMonthDayNanoArray::from(vec![
1620 Some(IntervalMonthDayNano::new(1, 0, 0)),
1621 None,
1622 Some(IntervalMonthDayNano::new(8, 0, 0)),
1623 None,
1624 Some(IntervalMonthDayNano::new(10, 0, 0)),
1625 ]);
1626 test_primitive_dyn_scalar(array);
1627
1628 let array = IntervalYearMonthArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1629 test_primitive_dyn_scalar(array);
1630 }
1631
1632 #[test]
1633 fn test_duration_dyn_scalar() {
1634 let array = DurationSecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1635 test_primitive_dyn_scalar(array);
1636
1637 let array = DurationMicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1638 test_primitive_dyn_scalar(array);
1639
1640 let array = DurationMillisecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1641 test_primitive_dyn_scalar(array);
1642
1643 let array = DurationNanosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
1644 test_primitive_dyn_scalar(array);
1645 }
1646
1647 #[test]
1648 fn test_lt_eq_dyn_scalar_with_dict() {
1649 let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
1650 builder.append(123).unwrap();
1651 builder.append_null();
1652 builder.append(23).unwrap();
1653 let array = builder.finish();
1654 let right = DictionaryArray::<Int8Type>::new_scalar(Int32Array::new_scalar(23));
1655 let a_eq = crate::cmp::lt_eq(&array, &right).unwrap();
1656 assert_eq!(
1657 a_eq,
1658 BooleanArray::from(vec![Some(false), None, Some(true)])
1659 );
1660 }
1661
1662 #[test]
1663 fn test_lt_eq_dyn_scalar_float() {
1664 let array = Float32Array::from(vec![6.0, 7.0, 8.0, 8.0, 10.0]);
1665 let b = Float32Array::new_scalar(8.);
1666 let expected = BooleanArray::from(vec![true, true,true,true,false]);
1667 assert_eq!(crate::cmp::lt_eq(&array, &b).unwrap(), expected);
1668
1669 let array = array.unary::<_, Float64Type>(|x| x as f64);
1670 let b = Float64Array::new_scalar(8.);
1671 assert_eq!(crate::cmp::lt_eq(&array, &b).unwrap(), expected);
1672 }
1673
1674 #[test]
1675 fn test_gt_dyn_scalar() {
1676 let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
1677 let scalar = Int32Array::new_scalar(8);
1678 let a_eq = crate::cmp::gt(&array, &scalar).unwrap();
1679 assert_eq!(
1680 a_eq,
1681 BooleanArray::from(
1682 vec![Some(false), Some(false), Some(false), Some(false), Some(true)]
1683 )
1684 );
1685 }
1686
1687 #[test]
1688 fn test_gt_dyn_scalar_with_dict() {
1689 let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
1690 builder.append(123).unwrap();
1691 builder.append_null();
1692 builder.append(23).unwrap();
1693 let array = builder.finish();
1694 let right = DictionaryArray::<Int8Type>::new_scalar(Int32Array::new_scalar(23));
1695 let a_eq = crate::cmp::gt(&array, &right).unwrap();
1696 assert_eq!(
1697 a_eq,
1698 BooleanArray::from(vec![Some(true), None, Some(false)])
1699 );
1700 }
1701
1702 #[test]
1703 fn test_gt_dyn_scalar_float() {
1704 let array = Float32Array::from(vec![6.0, 7.0, 8.0, 8.0, 10.0]);
1705 let expected = BooleanArray::from(vec![false,false,false,false,true]);
1706 let b = Float32Array::new_scalar(8.);
1707 assert_eq!(crate::cmp::gt(&array, &b).unwrap(), expected);
1708
1709 let array = array.unary::<_, Float64Type>(|x| x as f64);
1710 let b = Float64Array::new_scalar(8.);
1711 assert_eq!(crate::cmp::gt(&array, &b).unwrap(), expected);
1712 }
1713
1714 #[test]
1715 fn test_gt_eq_dyn_scalar() {
1716 let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
1717 let b = Int32Array::new_scalar(8);
1718 let a_eq = crate::cmp::gt_eq(&array, &b).unwrap();
1719 assert_eq!(a_eq, BooleanArray::from(vec![false,false,true,true,true]));
1720 }
1721
1722 #[test]
1723 fn test_gt_eq_dyn_scalar_with_dict() {
1724 let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
1725 builder.append(22).unwrap();
1726 builder.append_null();
1727 builder.append(23).unwrap();
1728 let array = builder.finish();
1729 let right = DictionaryArray::<Int8Type>::new_scalar(Int32Array::new_scalar(23));
1730 let a_eq = crate::cmp::gt_eq(&array, &right).unwrap();
1731 assert_eq!(
1732 a_eq,
1733 BooleanArray::from(vec![Some(false), None, Some(true)])
1734 );
1735 }
1736
1737 #[test]
1738 fn test_gt_eq_dyn_scalar_float() {
1739 let array = Float32Array::from(vec![6.0, 7.0, 8.0, 8.0, 10.0]);
1740 let b = Float32Array::new_scalar(8.);
1741 let expected = BooleanArray::from(vec![false, false,true,true,true]);
1742 assert_eq!(crate::cmp::gt_eq(&array, &b).unwrap(), expected);
1743
1744 let array = array.unary::<_, Float64Type>(|x| x as f64);
1745 let b = Float64Array::new_scalar(8.);
1746 assert_eq!(crate::cmp::gt_eq(&array, &b).unwrap(), expected);
1747 }
1748
1749 #[test]
1750 fn test_neq_dyn_scalar() {
1751 let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
1752 let scalar = Int32Array::new_scalar(8);
1753 let a_eq = crate::cmp::neq(&array, &scalar).unwrap();
1754 assert_eq!(
1755 a_eq,
1756 BooleanArray::from(vec![Some(true), Some(true), Some(false), Some(false), Some(true)])
1757 );
1758 }
1759
1760 #[test]
1761 fn test_neq_dyn_scalar_with_dict() {
1762 let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
1763 builder.append(22).unwrap();
1764 builder.append_null();
1765 builder.append(23).unwrap();
1766 let array = builder.finish();
1767 let scalar = DictionaryArray::<Int32Type>::new_scalar(Int32Array::new_scalar(23));
1768 let a_eq = crate::cmp::neq(&array, &scalar).unwrap();
1769 assert_eq!(
1770 a_eq,
1771 BooleanArray::from(vec![Some(true), None, Some(false)])
1772 );
1773 }
1774
1775 #[test]
1776 fn test_neq_dyn_scalar_float() {
1777 let array = Float32Array::from(vec![6.0, 7.0, 8.0, 8.0, 10.0]);
1778 let b = Float32Array::new_scalar(8.);
1779 let expected = BooleanArray::from(vec![true,true,false,false,true]);
1780 assert_eq!(crate::cmp::neq(&array, &b).unwrap(), expected);
1781
1782 let array = array.unary::<_, Float64Type>(|x| x as f64);
1783 let b = Float64Array::new_scalar(8.);
1784 assert_eq!(crate::cmp::neq(&array, &b).unwrap(), expected);
1785 }
1786
1787 #[test]
1788 fn test_eq_dyn_binary_scalar() {
1789 let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
1790 let array = BinaryArray::from(data.clone());
1791 let large_array = LargeBinaryArray::from(data);
1792 let scalar = BinaryArray::new_scalar("flight");
1793 let large_scalar = LargeBinaryArray::new_scalar("flight");
1794 let expected = BooleanArray::from(
1795 vec![Some(false), Some(false), Some(true), Some(false), Some(false), None],
1796 );
1797
1798 assert_eq!(crate::cmp::eq(&array, &scalar).unwrap(), expected);
1799 assert_eq!(
1800 crate::cmp::eq(&large_array, &large_scalar).unwrap(),
1801 expected
1802 );
1803
1804 let fsb_array = FixedSizeBinaryArray::from(vec![&[0u8], &[0u8], &[0u8], &[1u8]]);
1805 let scalar = FixedSizeBinaryArray::new_scalar([1u8]);
1806 let expected = BooleanArray::from(vec![Some(false), Some(false), Some(false), Some(true)]);
1807 assert_eq!(crate::cmp::eq(&fsb_array, &scalar).unwrap(), expected);
1808 }
1809
1810 #[test]
1811 fn test_neq_dyn_binary_scalar() {
1812 let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
1813 let array = BinaryArray::from(data.clone());
1814 let large_array = LargeBinaryArray::from(data);
1815 let scalar = BinaryArray::new_scalar("flight");
1816 let large_scalar = LargeBinaryArray::new_scalar("flight");
1817 let expected = BooleanArray::from(
1818 vec![Some(true), Some(true), Some(false), Some(true), Some(true), None],
1819 );
1820
1821 assert_eq!(crate::cmp::neq(&array, &scalar).unwrap(), expected);
1822 assert_eq!(
1823 crate::cmp::neq(&large_array, &large_scalar).unwrap(),
1824 expected
1825 );
1826
1827 let fsb_array = FixedSizeBinaryArray::from(vec![&[0u8], &[0u8], &[0u8], &[1u8]]);
1828 let scalar = FixedSizeBinaryArray::new_scalar([1u8]);
1829 let expected = BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(false)]);
1830 assert_eq!(crate::cmp::neq(&fsb_array, &scalar).unwrap(), expected);
1831 }
1832
1833 #[test]
1834 fn test_lt_dyn_binary_scalar() {
1835 let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
1836 let array = BinaryArray::from(data.clone());
1837 let large_array = LargeBinaryArray::from(data);
1838 let scalar = BinaryArray::new_scalar("flight");
1839 let large_scalar = LargeBinaryArray::new_scalar("flight");
1840 let expected = BooleanArray::from(
1841 vec![Some(true), Some(true), Some(false), Some(false), Some(false), None],
1842 );
1843
1844 assert_eq!(crate::cmp::lt(&array, &scalar).unwrap(), expected);
1845 assert_eq!(
1846 crate::cmp::lt(&large_array, &large_scalar).unwrap(),
1847 expected
1848 );
1849 }
1850
1851 #[test]
1852 fn test_lt_eq_dyn_binary_scalar() {
1853 let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
1854 let array = BinaryArray::from(data.clone());
1855 let large_array = LargeBinaryArray::from(data);
1856 let scalar = BinaryArray::new_scalar("flight");
1857 let large_scalar = LargeBinaryArray::new_scalar("flight");
1858 let expected = BooleanArray::from(
1859 vec![Some(true), Some(true), Some(true), Some(false), Some(false), None],
1860 );
1861
1862 assert_eq!(crate::cmp::lt_eq(&array, &scalar).unwrap(), expected);
1863 assert_eq!(
1864 crate::cmp::lt_eq(&large_array, &large_scalar).unwrap(),
1865 expected
1866 );
1867 }
1868
1869 #[test]
1870 fn test_gt_dyn_binary_scalar() {
1871 let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
1872 let array = BinaryArray::from(data.clone());
1873 let large_array = LargeBinaryArray::from(data);
1874 let scalar = BinaryArray::new_scalar("flight");
1875 let large_scalar = LargeBinaryArray::new_scalar("flight");
1876 let expected = BooleanArray::from(
1877 vec![Some(false), Some(false), Some(false), Some(true), Some(true), None],
1878 );
1879
1880 assert_eq!(crate::cmp::gt(&array, &scalar).unwrap(), expected);
1881 assert_eq!(
1882 crate::cmp::gt(&large_array, &large_scalar).unwrap(),
1883 expected
1884 );
1885 }
1886
1887 #[test]
1888 fn test_gt_eq_dyn_binary_scalar() {
1889 let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
1890 let array = BinaryArray::from(data.clone());
1891 let large_array = LargeBinaryArray::from(data);
1892 let scalar = BinaryArray::new_scalar([0xff, 0xf8]);
1893 let large_scalar = LargeBinaryArray::new_scalar([0xff, 0xf8]);
1894 let expected = BooleanArray::from(
1895 vec![Some(false), Some(false), Some(false), Some(false), Some(true), None],
1896 );
1897
1898 assert_eq!(crate::cmp::gt_eq(&array, &scalar).unwrap(), expected);
1899 assert_eq!(
1900 crate::cmp::gt_eq(&large_array, &large_scalar).unwrap(),
1901 expected
1902 );
1903 }
1904
1905 #[test]
1906 fn test_eq_dyn_utf8_scalar() {
1907 let array = StringArray::from(vec!["abc", "def", "xyz"]);
1908 let scalar = StringArray::new_scalar("xyz");
1909 let a_eq = crate::cmp::eq(&array, &scalar).unwrap();
1910 assert_eq!(
1911 a_eq,
1912 BooleanArray::from(vec![Some(false), Some(false), Some(true)])
1913 );
1914 }
1915
1916 #[test]
1917 fn test_eq_dyn_utf8_scalar_with_dict() {
1918 let mut builder = StringDictionaryBuilder::<Int8Type>::new();
1919 builder.append("abc").unwrap();
1920 builder.append_null();
1921 builder.append("def").unwrap();
1922 builder.append("def").unwrap();
1923 builder.append("abc").unwrap();
1924 let array = builder.finish();
1925 let scalar = DictionaryArray::<Int32Type>::new_scalar(StringArray::new_scalar("def"));
1926 let a_eq = crate::cmp::eq(&array, &scalar).unwrap();
1927 assert_eq!(
1928 a_eq,
1929 BooleanArray::from(vec![Some(false), None, Some(true), Some(true), Some(false)])
1930 );
1931 }
1932
1933 #[test]
1934 fn test_lt_dyn_utf8_scalar() {
1935 let array = StringArray::from(vec!["abc", "def", "xyz"]);
1936 let scalar = StringArray::new_scalar("xyz");
1937 let a_eq = crate::cmp::lt(&array, &scalar).unwrap();
1938 assert_eq!(
1939 a_eq,
1940 BooleanArray::from(vec![Some(true), Some(true), Some(false)])
1941 );
1942 }
1943
1944 #[test]
1945 fn test_lt_dyn_utf8_scalar_with_dict() {
1946 let mut builder = StringDictionaryBuilder::<Int8Type>::new();
1947 builder.append("abc").unwrap();
1948 builder.append_null();
1949 builder.append("def").unwrap();
1950 builder.append("def").unwrap();
1951 builder.append("abc").unwrap();
1952 let array = builder.finish();
1953 let scalar = DictionaryArray::<Int32Type>::new_scalar(StringArray::new_scalar("def"));
1954 let a_eq = crate::cmp::lt(&array, &scalar).unwrap();
1955 assert_eq!(
1956 a_eq,
1957 BooleanArray::from(vec![Some(true), None, Some(false), Some(false), Some(true)])
1958 );
1959 }
1960
1961 #[test]
1962 fn test_lt_eq_dyn_utf8_scalar() {
1963 let array = StringArray::from(vec!["abc", "def", "xyz"]);
1964 let scalar = StringArray::new_scalar("def");
1965 let a_eq = crate::cmp::lt_eq(&array, &scalar).unwrap();
1966 assert_eq!(
1967 a_eq,
1968 BooleanArray::from(vec![Some(true), Some(true), Some(false)])
1969 );
1970 }
1971
1972 #[test]
1973 fn test_lt_eq_dyn_utf8_scalar_with_dict() {
1974 let mut builder = StringDictionaryBuilder::<Int8Type>::new();
1975 builder.append("abc").unwrap();
1976 builder.append_null();
1977 builder.append("def").unwrap();
1978 builder.append("def").unwrap();
1979 builder.append("xyz").unwrap();
1980 let array = builder.finish();
1981 let scalar = DictionaryArray::<Int32Type>::new_scalar(StringArray::new_scalar("def"));
1982 let a_eq = crate::cmp::lt_eq(&array, &scalar).unwrap();
1983 assert_eq!(
1984 a_eq,
1985 BooleanArray::from(vec![Some(true), None, Some(true), Some(true), Some(false)])
1986 );
1987 }
1988
1989 #[test]
1990 fn test_gt_eq_dyn_utf8_scalar() {
1991 let array = StringArray::from(vec!["abc", "def", "xyz"]);
1992 let scalar = StringArray::new_scalar("def");
1993 let a_eq = crate::cmp::gt_eq(&array, &scalar).unwrap();
1994 assert_eq!(
1995 a_eq,
1996 BooleanArray::from(vec![Some(false), Some(true), Some(true)])
1997 );
1998 }
1999
2000 #[test]
2001 fn test_gt_eq_dyn_utf8_scalar_with_dict() {
2002 let mut builder = StringDictionaryBuilder::<Int8Type>::new();
2003 builder.append("abc").unwrap();
2004 builder.append_null();
2005 builder.append("def").unwrap();
2006 builder.append("def").unwrap();
2007 builder.append("xyz").unwrap();
2008 let array = builder.finish();
2009 let scalar = DictionaryArray::<Int32Type>::new_scalar(StringArray::new_scalar("def"));
2010 let a_eq = crate::cmp::gt_eq(&array, &scalar).unwrap();
2011 assert_eq!(
2012 a_eq,
2013 BooleanArray::from(vec![Some(false), None, Some(true), Some(true), Some(true)])
2014 );
2015 }
2016
2017 #[test]
2018 fn test_gt_dyn_utf8_scalar() {
2019 let array = StringArray::from(vec!["abc", "def", "xyz"]);
2020 let scalar = StringArray::new_scalar("def");
2021 let a_eq = crate::cmp::gt(&array, &scalar).unwrap();
2022 assert_eq!(
2023 a_eq,
2024 BooleanArray::from(vec![Some(false), Some(false), Some(true)])
2025 );
2026 }
2027
2028 #[test]
2029 fn test_gt_dyn_utf8_scalar_with_dict() {
2030 let mut builder = StringDictionaryBuilder::<Int8Type>::new();
2031 builder.append("abc").unwrap();
2032 builder.append_null();
2033 builder.append("def").unwrap();
2034 builder.append("def").unwrap();
2035 builder.append("xyz").unwrap();
2036 let array = builder.finish();
2037 let scalar = DictionaryArray::<Int32Type>::new_scalar(StringArray::new_scalar("def"));
2038 let a_eq = crate::cmp::gt(&array, &scalar).unwrap();
2039 assert_eq!(
2040 a_eq,
2041 BooleanArray::from(vec![Some(false), None, Some(false), Some(false), Some(true)])
2042 );
2043 }
2044
2045 #[test]
2046 fn test_neq_dyn_utf8_scalar() {
2047 let array = StringArray::from(vec!["abc", "def", "xyz"]);
2048 let scalar = StringArray::new_scalar("xyz");
2049 let a_eq = crate::cmp::neq(&array, &scalar).unwrap();
2050 assert_eq!(
2051 a_eq,
2052 BooleanArray::from(vec![Some(true), Some(true), Some(false)])
2053 );
2054 }
2055
2056 #[test]
2057 fn test_neq_dyn_utf8_scalar_with_dict() {
2058 let mut builder = StringDictionaryBuilder::<Int8Type>::new();
2059 builder.append("abc").unwrap();
2060 builder.append_null();
2061 builder.append("def").unwrap();
2062 builder.append("def").unwrap();
2063 builder.append("abc").unwrap();
2064 let array = builder.finish();
2065 let scalar = DictionaryArray::<Int32Type>::new_scalar(StringArray::new_scalar("def"));
2066 let a_eq = crate::cmp::neq(&array, &scalar).unwrap();
2067 assert_eq!(
2068 a_eq,
2069 BooleanArray::from(vec![Some(true), None, Some(false), Some(false), Some(true)])
2070 );
2071 }
2072
2073 #[test]
2074 fn test_eq_dyn_bool_scalar() {
2075 let array = BooleanArray::from(vec![true, false, true]);
2076 let scalar = BooleanArray::new_scalar(false);
2077 let a_eq = crate::cmp::eq(&array, &scalar).unwrap();
2078 assert_eq!(
2079 a_eq,
2080 BooleanArray::from(vec![Some(false), Some(true), Some(false)])
2081 );
2082 }
2083
2084 #[test]
2085 fn test_lt_dyn_bool_scalar() {
2086 let array = BooleanArray::from(vec![Some(true), Some(false), Some(true), None]);
2087 let scalar = BooleanArray::new_scalar(false);
2088 let a_eq = crate::cmp::lt(&array, &scalar).unwrap();
2089 assert_eq!(
2090 a_eq,
2091 BooleanArray::from(vec![Some(false), Some(false), Some(false), None])
2092 );
2093 }
2094
2095 #[test]
2096 fn test_gt_dyn_bool_scalar() {
2097 let array = BooleanArray::from(vec![true, false, true]);
2098 let scalar = BooleanArray::new_scalar(false);
2099 let a_eq = crate::cmp::gt(&array, &scalar).unwrap();
2100 assert_eq!(
2101 a_eq,
2102 BooleanArray::from(vec![Some(true), Some(false), Some(true)])
2103 );
2104 }
2105
2106 #[test]
2107 fn test_lt_eq_dyn_bool_scalar() {
2108 let array = BooleanArray::from(vec![true, false, true]);
2109 let scalar = BooleanArray::new_scalar(false);
2110 let a_eq = crate::cmp::lt_eq(&array, &scalar).unwrap();
2111 assert_eq!(
2112 a_eq,
2113 BooleanArray::from(vec![Some(false), Some(true), Some(false)])
2114 );
2115 }
2116
2117 #[test]
2118 fn test_gt_eq_dyn_bool_scalar() {
2119 let array = BooleanArray::from(vec![true, false, true]);
2120 let scalar = BooleanArray::new_scalar(false);
2121 let a_eq = crate::cmp::gt_eq(&array, &scalar).unwrap();
2122 assert_eq!(
2123 a_eq,
2124 BooleanArray::from(vec![Some(true), Some(true), Some(true)])
2125 );
2126 }
2127
2128 #[test]
2129 fn test_neq_dyn_bool_scalar() {
2130 let array = BooleanArray::from(vec![true, false, true]);
2131 let scalar = BooleanArray::new_scalar(false);
2132 let a_eq = crate::cmp::neq(&array, &scalar).unwrap();
2133 assert_eq!(
2134 a_eq,
2135 BooleanArray::from(vec![Some(true), Some(false), Some(true)])
2136 );
2137 }
2138
2139 #[test]
2140 fn test_eq_dyn_neq_dyn_fixed_size_binary() {
2141 let values1: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36, 0x01])];
2142 let values2: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36, 0x00])];
2143
2144 let array1 =
2145 FixedSizeBinaryArray::try_from_sparse_iter_with_size(values1.into_iter(), 2).unwrap();
2146 let array2 =
2147 FixedSizeBinaryArray::try_from_sparse_iter_with_size(values2.into_iter(), 2).unwrap();
2148
2149 let result = crate::cmp::eq(&array1, &array2).unwrap();
2150 assert_eq!(
2151 BooleanArray::from(vec![Some(true), None, Some(false)]),
2152 result
2153 );
2154
2155 let result = crate::cmp::neq(&array1, &array2).unwrap();
2156 assert_eq!(
2157 BooleanArray::from(vec![Some(false), None, Some(true)]),
2158 result
2159 );
2160 }
2161
2162 #[test]
2163 fn test_eq_dyn_neq_dyn_dictionary_i8_array() {
2164 let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
2166 let values = Arc::new(values) as ArrayRef;
2167
2168 let keys1 = Int8Array::from_iter_values([2_i8, 3, 4]);
2169 let keys2 = Int8Array::from_iter_values([2_i8, 4, 4]);
2170 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2171 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2172
2173 let result = crate::cmp::eq(&dict_array1, &dict_array2);
2174 assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
2175
2176 let result = crate::cmp::neq(&dict_array1, &dict_array2);
2177 assert_eq!(
2178 result.unwrap(),
2179 BooleanArray::from(vec![false, true, false])
2180 );
2181 }
2182
2183 #[test]
2184 fn test_eq_dyn_neq_dyn_dictionary_u64_array() {
2185 let values = UInt64Array::from_iter_values([10_u64, 11, 12, 13, 14, 15, 16, 17]);
2186 let values = Arc::new(values) as ArrayRef;
2187
2188 let keys1 = UInt64Array::from_iter_values([1_u64, 3, 4]);
2189 let keys2 = UInt64Array::from_iter_values([2_u64, 3, 5]);
2190 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2191 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2192
2193 let result = crate::cmp::eq(&dict_array1, &dict_array2);
2194 assert_eq!(
2195 result.unwrap(),
2196 BooleanArray::from(vec![false, true, false])
2197 );
2198
2199 let result = crate::cmp::neq(&dict_array1, &dict_array2);
2200 assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
2201 }
2202
2203 #[test]
2204 fn test_eq_dyn_neq_dyn_dictionary_utf8_array() {
2205 let test1 = ["a", "a", "b", "c"];
2206 let test2 = ["a", "b", "b", "c"];
2207
2208 let dict_array1: DictionaryArray<Int8Type> = test1
2209 .iter()
2210 .map(|&x| if x == "b" { None } else { Some(x) })
2211 .collect();
2212 let dict_array2: DictionaryArray<Int8Type> = test2
2213 .iter()
2214 .map(|&x| if x == "b" { None } else { Some(x) })
2215 .collect();
2216
2217 let result = crate::cmp::eq(&dict_array1, &dict_array2);
2218 assert_eq!(
2219 result.unwrap(),
2220 BooleanArray::from(vec![Some(true), None, None, Some(true)])
2221 );
2222
2223 let result = crate::cmp::neq(&dict_array1, &dict_array2);
2224 assert_eq!(
2225 result.unwrap(),
2226 BooleanArray::from(vec![Some(false), None, None, Some(false)])
2227 );
2228 }
2229
2230 #[test]
2231 fn test_eq_dyn_neq_dyn_dictionary_binary_array() {
2232 let values: BinaryArray = ["hello", "", "parquet"]
2233 .into_iter()
2234 .map(|b| Some(b.as_bytes()))
2235 .collect();
2236 let values = Arc::new(values) as ArrayRef;
2237
2238 let keys1 = UInt64Array::from_iter_values([0_u64, 1, 2]);
2239 let keys2 = UInt64Array::from_iter_values([0_u64, 2, 1]);
2240 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2241 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2242
2243 let result = crate::cmp::eq(&dict_array1, &dict_array2);
2244 assert_eq!(
2245 result.unwrap(),
2246 BooleanArray::from(vec![true, false, false])
2247 );
2248
2249 let result = crate::cmp::neq(&dict_array1, &dict_array2);
2250 assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
2251 }
2252
2253 #[test]
2254 fn test_eq_dyn_neq_dyn_dictionary_interval_array() {
2255 let values = IntervalDayTimeArray::from(vec![
2256 Some(IntervalDayTime::new(0, 1)),
2257 Some(IntervalDayTime::new(0, 1)),
2258 Some(IntervalDayTime::new(0, 6)),
2259 Some(IntervalDayTime::new(4, 10)),
2260 ]);
2261 let values = Arc::new(values) as ArrayRef;
2262
2263 let keys1 = UInt64Array::from_iter_values([1_u64, 0, 3]);
2264 let keys2 = UInt64Array::from_iter_values([2_u64, 1, 3]);
2265 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2266 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2267
2268 let result = crate::cmp::eq(&dict_array1, &dict_array2);
2269 assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
2270
2271 let result = crate::cmp::neq(&dict_array1, &dict_array2);
2272 assert_eq!(
2273 result.unwrap(),
2274 BooleanArray::from(vec![true, false, false])
2275 );
2276 }
2277
2278 #[test]
2279 fn test_eq_dyn_neq_dyn_dictionary_date_array() {
2280 let values = Date32Array::from(vec![1, 6, 10, 2, 3, 5]);
2281 let values = Arc::new(values) as ArrayRef;
2282
2283 let keys1 = UInt64Array::from_iter_values([1_u64, 0, 3]);
2284 let keys2 = UInt64Array::from_iter_values([2_u64, 0, 3]);
2285 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2286 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2287
2288 let result = crate::cmp::eq(&dict_array1, &dict_array2);
2289 assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
2290
2291 let result = crate::cmp::neq(&dict_array1, &dict_array2);
2292 assert_eq!(
2293 result.unwrap(),
2294 BooleanArray::from(vec![true, false, false])
2295 );
2296 }
2297
2298 #[test]
2299 fn test_eq_dyn_neq_dyn_dictionary_bool_array() {
2300 let values = BooleanArray::from(vec![true, false]);
2301 let values = Arc::new(values) as ArrayRef;
2302
2303 let keys1 = UInt64Array::from_iter_values([1_u64, 1, 1]);
2304 let keys2 = UInt64Array::from_iter_values([0_u64, 1, 0]);
2305 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2306 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2307
2308 let result = crate::cmp::eq(&dict_array1, &dict_array2);
2309 assert_eq!(
2310 result.unwrap(),
2311 BooleanArray::from(vec![false, true, false])
2312 );
2313
2314 let result = crate::cmp::neq(&dict_array1, &dict_array2);
2315 assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
2316 }
2317
2318 #[test]
2319 fn test_lt_dyn_gt_dyn_dictionary_i8_array() {
2320 let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
2322 let values = Arc::new(values) as ArrayRef;
2323
2324 let keys1 = Int8Array::from_iter_values([3_i8, 4, 4]);
2325 let keys2 = Int8Array::from_iter_values([4_i8, 3, 4]);
2326 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2327 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2328
2329 let result = crate::cmp::lt(&dict_array1, &dict_array2);
2330 assert_eq!(
2331 result.unwrap(),
2332 BooleanArray::from(vec![true, false, false])
2333 );
2334
2335 let result = crate::cmp::lt_eq(&dict_array1, &dict_array2);
2336 assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
2337
2338 let result = crate::cmp::gt(&dict_array1, &dict_array2);
2339 assert_eq!(
2340 result.unwrap(),
2341 BooleanArray::from(vec![false, true, false])
2342 );
2343
2344 let result = crate::cmp::gt_eq(&dict_array1, &dict_array2);
2345 assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
2346 }
2347
2348 #[test]
2349 fn test_lt_dyn_gt_dyn_dictionary_bool_array() {
2350 let values = BooleanArray::from(vec![true, false]);
2351 let values = Arc::new(values) as ArrayRef;
2352
2353 let keys1 = UInt64Array::from_iter_values([1_u64, 1, 0]);
2354 let keys2 = UInt64Array::from_iter_values([0_u64, 1, 1]);
2355 let dict_array1 = DictionaryArray::new(keys1, values.clone());
2356 let dict_array2 = DictionaryArray::new(keys2, values.clone());
2357
2358 let result = crate::cmp::lt(&dict_array1, &dict_array2);
2359 assert_eq!(
2360 result.unwrap(),
2361 BooleanArray::from(vec![true, false, false])
2362 );
2363
2364 let result = crate::cmp::lt_eq(&dict_array1, &dict_array2);
2365 assert_eq!(result.unwrap(), BooleanArray::from(vec![true, true, false]));
2366
2367 let result = crate::cmp::gt(&dict_array1, &dict_array2);
2368 assert_eq!(
2369 result.unwrap(),
2370 BooleanArray::from(vec![false, false, true])
2371 );
2372
2373 let result = crate::cmp::gt_eq(&dict_array1, &dict_array2);
2374 assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
2375 }
2376
2377 #[test]
2378 fn test_eq_dyn_neq_dyn_dictionary_i8_i8_array() {
2379 let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
2380 let keys = Int8Array::from_iter_values([2_i8, 3, 4]);
2381
2382 let dict_array = DictionaryArray::new(keys, Arc::new(values));
2383
2384 let array = Int8Array::from_iter([Some(12_i8), None, Some(14)]);
2385
2386 let result = crate::cmp::eq(&dict_array, &array);
2387 assert_eq!(
2388 result.unwrap(),
2389 BooleanArray::from(vec![Some(true), None, Some(true)])
2390 );
2391
2392 let result = crate::cmp::eq(&array, &dict_array);
2393 assert_eq!(
2394 result.unwrap(),
2395 BooleanArray::from(vec![Some(true), None, Some(true)])
2396 );
2397
2398 let result = crate::cmp::neq(&dict_array, &array);
2399 assert_eq!(
2400 result.unwrap(),
2401 BooleanArray::from(vec![Some(false), None, Some(false)])
2402 );
2403
2404 let result = crate::cmp::neq(&array, &dict_array);
2405 assert_eq!(
2406 result.unwrap(),
2407 BooleanArray::from(vec![Some(false), None, Some(false)])
2408 );
2409 }
2410
2411 #[test]
2412 fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_i8_i8_array() {
2413 let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
2414 let keys = Int8Array::from_iter_values([2_i8, 3, 4]);
2415
2416 let dict_array = DictionaryArray::new(keys, Arc::new(values));
2417
2418 let array = Int8Array::from_iter([Some(12_i8), None, Some(11)]);
2419
2420 let result = crate::cmp::lt(&dict_array, &array);
2421 assert_eq!(
2422 result.unwrap(),
2423 BooleanArray::from(vec![Some(false), None, Some(false)])
2424 );
2425
2426 let result = crate::cmp::lt(&array, &dict_array);
2427 assert_eq!(
2428 result.unwrap(),
2429 BooleanArray::from(vec![Some(false), None, Some(true)])
2430 );
2431
2432 let result = crate::cmp::lt_eq(&dict_array, &array);
2433 assert_eq!(
2434 result.unwrap(),
2435 BooleanArray::from(vec![Some(true), None, Some(false)])
2436 );
2437
2438 let result = crate::cmp::lt_eq(&array, &dict_array);
2439 assert_eq!(
2440 result.unwrap(),
2441 BooleanArray::from(vec![Some(true), None, Some(true)])
2442 );
2443
2444 let result = crate::cmp::gt(&dict_array, &array);
2445 assert_eq!(
2446 result.unwrap(),
2447 BooleanArray::from(vec![Some(false), None, Some(true)])
2448 );
2449
2450 let result = crate::cmp::gt(&array, &dict_array);
2451 assert_eq!(
2452 result.unwrap(),
2453 BooleanArray::from(vec![Some(false), None, Some(false)])
2454 );
2455
2456 let result = crate::cmp::gt_eq(&dict_array, &array);
2457 assert_eq!(
2458 result.unwrap(),
2459 BooleanArray::from(vec![Some(true), None, Some(true)])
2460 );
2461
2462 let result = crate::cmp::gt_eq(&array, &dict_array);
2463 assert_eq!(
2464 result.unwrap(),
2465 BooleanArray::from(vec![Some(true), None, Some(false)])
2466 );
2467 }
2468
2469 #[test]
2470 fn test_eq_dyn_neq_dyn_float_nan() {
2471 let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
2472 let array2 = Float16Array::from(
2473 vec![f16::NAN, f16::NAN, f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)],
2474 );
2475 let expected = BooleanArray::from(vec![true, false, true, true, true]);
2476 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
2477
2478 let expected = BooleanArray::from(vec![false, true, false, false, false]);
2479 assert_eq!(crate::cmp::neq(&array1, &array2).unwrap(), expected);
2480
2481 let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
2482 let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 8.0, 10.0]);
2483 let expected = BooleanArray::from(vec![true, false, true, true, true]);
2484 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
2485
2486 let expected = BooleanArray::from(vec![false, true, false, false, false]);
2487 assert_eq!(crate::cmp::neq(&array1, &array2).unwrap(), expected);
2488
2489 let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
2490 let array2 = Float64Array::from(vec![f64::NAN, f64::NAN, 8.0, 8.0, 10.0]);
2491
2492 let expected = BooleanArray::from(vec![true, false, true, true, true]);
2493 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
2494
2495 let expected = BooleanArray::from(vec![false, true, false, false, false]);
2496 assert_eq!(crate::cmp::neq(&array1, &array2).unwrap(), expected);
2497 }
2498
2499 #[test]
2500 fn test_lt_dyn_lt_eq_dyn_float_nan() {
2501 let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
2502 let array2 = Float16Array::from(vec![f16::NAN, f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
2503
2504 let expected = BooleanArray::from(vec![false, true, false, true, false, false]);
2505 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
2506
2507 let expected = BooleanArray::from(vec![true, true, true, true, false, false]);
2508 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
2509
2510 let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]);
2511 let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0, 1.0]);
2512
2513 let expected = BooleanArray::from(vec![false, true, false, true, false, false]);
2514 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
2515
2516 let expected = BooleanArray::from(vec![true, true, true, true, false, false]);
2517 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
2518
2519 let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]);
2520 let array2: Float64Array =
2521 Float64Array::from(vec![f64::NAN, f64::NAN, 8.0, 9.0, 10.0, 1.0]);
2522
2523 let expected = BooleanArray::from(vec![false, true, false, true, false, false]);
2524 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
2525
2526 let expected = BooleanArray::from(vec![true, true, true, true, false, false]);
2527 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
2528 }
2529
2530 #[test]
2531 fn test_gt_dyn_gt_eq_dyn_float_nan() {
2532 let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
2533 let array2 = Float16Array::from(vec![f16::NAN, f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
2534
2535 let expected = BooleanArray::from(vec![false, false, false, false, true, true]);
2536 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
2537
2538 let expected = BooleanArray::from(vec![true, false, true, false, true, true]);
2539 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
2540
2541 let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]);
2542 let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0, 1.0]);
2543
2544 let expected = BooleanArray::from(vec![false, false, false, false, true, true]);
2545 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
2546
2547 let expected = BooleanArray::from(vec![true, false, true, false, true, true]);
2548 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
2549
2550 let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]);
2551 let array2 = Float64Array::from(vec![f64::NAN, f64::NAN, 8.0, 9.0, 10.0, 1.0]);
2552
2553 let expected = BooleanArray::from(vec![false, false, false, false, true, true]);
2554 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
2555
2556 let expected = BooleanArray::from(vec![true, false, true, false, true, true]);
2557 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
2558 }
2559
2560 #[test]
2561 fn test_eq_dyn_scalar_neq_dyn_scalar_float_nan() {
2562 let array = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
2563 let scalar = Float16Array::new_scalar(f16::NAN);
2564
2565 let expected = BooleanArray::from(vec![true, false, false, false, false]);
2566 assert_eq!(crate::cmp::eq(&array, &scalar).unwrap(), expected);
2567
2568 let expected = BooleanArray::from(vec![false, true, true, true, true]);
2569 assert_eq!(crate::cmp::neq(&array, &scalar).unwrap(), expected);
2570
2571 let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
2572 let scalar = Float32Array::new_scalar(f32::NAN);
2573 let expected = BooleanArray::from(vec![true, false, false, false, false]);
2574 assert_eq!(crate::cmp::eq(&array, &scalar).unwrap(), expected);
2575
2576 let expected = BooleanArray::from(vec![false, true, true, true, true]);
2577 assert_eq!(crate::cmp::neq(&array, &scalar).unwrap(), expected);
2578
2579 let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
2580 let scalar = Float64Array::new_scalar(f64::NAN);
2581 let expected = BooleanArray::from(vec![true, false, false, false, false]);
2582 assert_eq!(crate::cmp::eq(&array, &scalar).unwrap(), expected);
2583
2584 let expected = BooleanArray::from(vec![false, true, true, true, true]);
2585 assert_eq!(crate::cmp::neq(&array, &scalar).unwrap(), expected);
2586 }
2587
2588 #[test]
2589 fn test_lt_dyn_scalar_lt_eq_dyn_scalar_float_nan() {
2590 let array = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
2591 let scalar = Float16Array::new_scalar(f16::NAN);
2592
2593 let expected = BooleanArray::from(vec![false, true, true, true, true]);
2594 assert_eq!(crate::cmp::lt(&array, &scalar).unwrap(), expected);
2595
2596 let expected = BooleanArray::from(vec![true, true, true, true, true]);
2597 assert_eq!(crate::cmp::lt_eq(&array, &scalar).unwrap(), expected);
2598
2599 let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
2600 let scalar = Float32Array::new_scalar(f32::NAN);
2601
2602 let expected = BooleanArray::from(vec![false, true, true, true, true]);
2603 assert_eq!(crate::cmp::lt(&array, &scalar).unwrap(), expected);
2604
2605 let expected = BooleanArray::from(vec![true, true, true, true, true]);
2606 assert_eq!(crate::cmp::lt_eq(&array, &scalar).unwrap(), expected);
2607
2608 let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
2609 let scalar = Float64Array::new_scalar(f64::NAN);
2610 let expected = BooleanArray::from(vec![false, true, true, true, true]);
2611 assert_eq!(crate::cmp::lt(&array, &scalar).unwrap(), expected);
2612
2613 let expected = BooleanArray::from(vec![true, true, true, true, true]);
2614 assert_eq!(crate::cmp::lt_eq(&array, &scalar).unwrap(), expected);
2615 }
2616
2617 #[test]
2618 fn test_gt_dyn_scalar_gt_eq_dyn_scalar_float_nan() {
2619 let array = Float16Array::from(vec![
2620 f16::NAN,
2621 f16::from_f32(7.0),
2622 f16::from_f32(8.0),
2623 f16::from_f32(8.0),
2624 f16::from_f32(10.0),
2625 ]);
2626 let scalar = Float16Array::new_scalar(f16::NAN);
2627 let expected = BooleanArray::from(vec![false, false, false, false, false]);
2628 assert_eq!(crate::cmp::gt(&array, &scalar).unwrap(), expected);
2629
2630 let expected = BooleanArray::from(vec![true, false, false, false, false]);
2631 assert_eq!(crate::cmp::gt_eq(&array, &scalar).unwrap(), expected);
2632
2633 let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
2634 let scalar = Float32Array::new_scalar(f32::NAN);
2635 let expected = BooleanArray::from(vec![false, false, false, false, false]);
2636 assert_eq!(crate::cmp::gt(&array, &scalar).unwrap(), expected);
2637
2638 let expected = BooleanArray::from(vec![true, false, false, false, false]);
2639 assert_eq!(crate::cmp::gt_eq(&array, &scalar).unwrap(), expected);
2640
2641 let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
2642 let scalar = Float64Array::new_scalar(f64::NAN);
2643 let expected = BooleanArray::from(vec![false, false, false, false, false]);
2644 assert_eq!(crate::cmp::gt(&array, &scalar).unwrap(), expected);
2645
2646 let expected = BooleanArray::from(vec![true, false, false, false, false]);
2647 assert_eq!(crate::cmp::gt_eq(&array, &scalar).unwrap(), expected);
2648 }
2649
2650 #[test]
2651 fn test_eq_dyn_neq_dyn_dictionary_to_utf8_array() {
2652 let test1 = ["a", "a", "b", "c"];
2653 let test2 = ["a", "b", "b", "d"];
2654
2655 let dict_array: DictionaryArray<Int8Type> = test1
2656 .iter()
2657 .map(|&x| if x == "b" { None } else { Some(x) })
2658 .collect();
2659
2660 let array: StringArray = test2
2661 .iter()
2662 .map(|&x| if x == "b" { None } else { Some(x) })
2663 .collect();
2664
2665 let result = crate::cmp::eq(&dict_array, &array);
2666 assert_eq!(
2667 result.unwrap(),
2668 BooleanArray::from(vec![Some(true), None, None, Some(false)])
2669 );
2670
2671 let result = crate::cmp::eq(&array, &dict_array);
2672 assert_eq!(
2673 result.unwrap(),
2674 BooleanArray::from(vec![Some(true), None, None, Some(false)])
2675 );
2676
2677 let result = crate::cmp::neq(&dict_array, &array);
2678 assert_eq!(
2679 result.unwrap(),
2680 BooleanArray::from(vec![Some(false), None, None, Some(true)])
2681 );
2682
2683 let result = crate::cmp::neq(&array, &dict_array);
2684 assert_eq!(
2685 result.unwrap(),
2686 BooleanArray::from(vec![Some(false), None, None, Some(true)])
2687 );
2688 }
2689
2690 #[test]
2691 fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_to_utf8_array() {
2692 let test1 = ["abc", "abc", "b", "cde"];
2693 let test2 = ["abc", "b", "b", "def"];
2694
2695 let dict_array: DictionaryArray<Int8Type> = test1
2696 .iter()
2697 .map(|&x| if x == "b" { None } else { Some(x) })
2698 .collect();
2699
2700 let array: StringArray = test2
2701 .iter()
2702 .map(|&x| if x == "b" { None } else { Some(x) })
2703 .collect();
2704
2705 let result = crate::cmp::lt(&dict_array, &array);
2706 assert_eq!(
2707 result.unwrap(),
2708 BooleanArray::from(vec![Some(false), None, None, Some(true)])
2709 );
2710
2711 let result = crate::cmp::lt(&array, &dict_array);
2712 assert_eq!(
2713 result.unwrap(),
2714 BooleanArray::from(vec![Some(false), None, None, Some(false)])
2715 );
2716
2717 let result = crate::cmp::lt_eq(&dict_array, &array);
2718 assert_eq!(
2719 result.unwrap(),
2720 BooleanArray::from(vec![Some(true), None, None, Some(true)])
2721 );
2722
2723 let result = crate::cmp::lt_eq(&array, &dict_array);
2724 assert_eq!(
2725 result.unwrap(),
2726 BooleanArray::from(vec![Some(true), None, None, Some(false)])
2727 );
2728
2729 let result = crate::cmp::gt(&dict_array, &array);
2730 assert_eq!(
2731 result.unwrap(),
2732 BooleanArray::from(vec![Some(false), None, None, Some(false)])
2733 );
2734
2735 let result = crate::cmp::gt(&array, &dict_array);
2736 assert_eq!(
2737 result.unwrap(),
2738 BooleanArray::from(vec![Some(false), None, None, Some(true)])
2739 );
2740
2741 let result = crate::cmp::gt_eq(&dict_array, &array);
2742 assert_eq!(
2743 result.unwrap(),
2744 BooleanArray::from(vec![Some(true), None, None, Some(false)])
2745 );
2746
2747 let result = crate::cmp::gt_eq(&array, &dict_array);
2748 assert_eq!(
2749 result.unwrap(),
2750 BooleanArray::from(vec![Some(true), None, None, Some(true)])
2751 );
2752 }
2753
2754 #[test]
2755 fn test_eq_dyn_neq_dyn_dictionary_to_binary_array() {
2756 let values: BinaryArray = ["hello", "", "parquet"]
2757 .into_iter()
2758 .map(|b| Some(b.as_bytes()))
2759 .collect();
2760
2761 let keys = UInt64Array::from(vec![Some(0_u64), None, Some(2), Some(2)]);
2762 let dict_array = DictionaryArray::new(keys, Arc::new(values));
2763
2764 let array: BinaryArray = ["hello", "", "parquet", "test"]
2765 .into_iter()
2766 .map(|b| Some(b.as_bytes()))
2767 .collect();
2768
2769 let result = crate::cmp::eq(&dict_array, &array);
2770 assert_eq!(
2771 result.unwrap(),
2772 BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
2773 );
2774
2775 let result = crate::cmp::eq(&array, &dict_array);
2776 assert_eq!(
2777 result.unwrap(),
2778 BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
2779 );
2780
2781 let result = crate::cmp::neq(&dict_array, &array);
2782 assert_eq!(
2783 result.unwrap(),
2784 BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
2785 );
2786
2787 let result = crate::cmp::neq(&array, &dict_array);
2788 assert_eq!(
2789 result.unwrap(),
2790 BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
2791 );
2792 }
2793
2794 #[test]
2795 fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_to_binary_array() {
2796 let values: BinaryArray = ["hello", "", "parquet"]
2797 .into_iter()
2798 .map(|b| Some(b.as_bytes()))
2799 .collect();
2800
2801 let keys = UInt64Array::from(vec![Some(0_u64), None, Some(2), Some(2)]);
2802 let dict_array = DictionaryArray::new(keys, Arc::new(values));
2803
2804 let array: BinaryArray = ["hello", "", "parquet", "test"]
2805 .into_iter()
2806 .map(|b| Some(b.as_bytes()))
2807 .collect();
2808
2809 let result = crate::cmp::lt(&dict_array, &array);
2810 assert_eq!(
2811 result.unwrap(),
2812 BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
2813 );
2814
2815 let result = crate::cmp::lt(&array, &dict_array);
2816 assert_eq!(
2817 result.unwrap(),
2818 BooleanArray::from(vec![Some(false), None, Some(false), Some(false)])
2819 );
2820
2821 let result = crate::cmp::lt_eq(&dict_array, &array);
2822 assert_eq!(
2823 result.unwrap(),
2824 BooleanArray::from(vec![Some(true), None, Some(true), Some(true)])
2825 );
2826
2827 let result = crate::cmp::lt_eq(&array, &dict_array);
2828 assert_eq!(
2829 result.unwrap(),
2830 BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
2831 );
2832
2833 let result = crate::cmp::gt(&dict_array, &array);
2834 assert_eq!(
2835 result.unwrap(),
2836 BooleanArray::from(vec![Some(false), None, Some(false), Some(false)])
2837 );
2838
2839 let result = crate::cmp::gt(&array, &dict_array);
2840 assert_eq!(
2841 result.unwrap(),
2842 BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
2843 );
2844
2845 let result = crate::cmp::gt_eq(&dict_array, &array);
2846 assert_eq!(
2847 result.unwrap(),
2848 BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
2849 );
2850
2851 let result = crate::cmp::gt_eq(&array, &dict_array);
2852 assert_eq!(
2853 result.unwrap(),
2854 BooleanArray::from(vec![Some(true), None, Some(true), Some(true)])
2855 );
2856 }
2857
2858 #[test]
2859 fn test_eq_dyn_neq_dyn_dict_non_dict_float_nan() {
2860 let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
2861 let values = Float16Array::from(vec![f16::NAN, f16::from_f32(8.0), f16::from_f32(10.0)]);
2862 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 1, 2]);
2863 let array2 = DictionaryArray::new(keys, Arc::new(values));
2864
2865 let expected = BooleanArray::from(vec![true, false, true, true, true]);
2866 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
2867
2868 let expected = BooleanArray::from(vec![false, true, false, false, false]);
2869 assert_eq!(crate::cmp::neq(&array1, &array2).unwrap(), expected);
2870
2871 let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
2872 let values = Float32Array::from(vec![f32::NAN, 8.0, 10.0]);
2873 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 1, 2]);
2874 let array2 = DictionaryArray::new(keys, Arc::new(values));
2875
2876 let expected = BooleanArray::from(vec![true, false, true, true, true]);
2877 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
2878
2879 let expected = BooleanArray::from(vec![false, true, false, false, false]);
2880 assert_eq!(crate::cmp::neq(&array1, &array2).unwrap(), expected);
2881
2882 let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
2883 let values = Float64Array::from(vec![f64::NAN, 8.0, 10.0]);
2884 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 1, 2]);
2885 let array2 = DictionaryArray::new(keys, Arc::new(values));
2886
2887 let expected = BooleanArray::from(vec![true, false, true, true, true]);
2888 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
2889
2890 let expected = BooleanArray::from(vec![false, true, false, false, false]);
2891 assert_eq!(crate::cmp::neq(&array1, &array2).unwrap(), expected);
2892 }
2893
2894 #[test]
2895 fn test_lt_dyn_lt_eq_dyn_dict_non_dict_float_nan() {
2896 let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
2897 let values = Float16Array::from(vec![f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
2898 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
2899 let array2 = DictionaryArray::new(keys, Arc::new(values));
2900
2901 let expected = BooleanArray::from(vec![false, true, false, true, false, false]);
2902 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
2903
2904 let expected = BooleanArray::from(vec![true, true, true, true, false, false]);
2905 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
2906
2907 let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]);
2908 let values = Float32Array::from(vec![f32::NAN, 8.0, 9.0, 10.0, 1.0]);
2909 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
2910 let array2 = DictionaryArray::new(keys, Arc::new(values));
2911
2912 let expected = BooleanArray::from(vec![false, true, false, true, false, false]);
2913 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
2914
2915 let expected = BooleanArray::from(vec![true, true, true, true, false, false]);
2916 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
2917
2918 let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]);
2919 let values = Float64Array::from(vec![f64::NAN, 8.0, 9.0, 10.0, 1.0]);
2920 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
2921 let array2 = DictionaryArray::new(keys, Arc::new(values));
2922
2923 let expected = BooleanArray::from(vec![false, true, false, true, false, false]);
2924 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
2925
2926 let expected = BooleanArray::from(vec![true, true, true, true, false, false]);
2927 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
2928 }
2929
2930 #[test]
2931 fn test_gt_dyn_gt_eq_dyn_dict_non_dict_float_nan() {
2932 let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
2933 let values = Float16Array::from(vec![f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
2934 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
2935 let array2 = DictionaryArray::new(keys, Arc::new(values));
2936
2937 let expected = BooleanArray::from(vec![false, false, false, false, true, true]);
2938 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
2939
2940 let expected = BooleanArray::from(vec![true, false, true, false, true, true]);
2941 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
2942
2943 let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]);
2944 let values = Float32Array::from(vec![f32::NAN, 8.0, 9.0, 10.0, 1.0]);
2945 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
2946 let array2 = DictionaryArray::new(keys, Arc::new(values));
2947
2948 let expected = BooleanArray::from(vec![false, false, false, false, true, true]);
2949 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
2950
2951 let expected = BooleanArray::from(vec![true, false, true, false, true, true]);
2952 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
2953
2954 let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]);
2955 let values = Float64Array::from(vec![f64::NAN, 8.0, 9.0, 10.0, 1.0]);
2956 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
2957 let array2 = DictionaryArray::new(keys, Arc::new(values));
2958
2959 let expected = BooleanArray::from(vec![false, false, false, false, true, true]);
2960 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
2961
2962 let expected = BooleanArray::from(vec![true, false, true, false, true, true]);
2963 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
2964 }
2965
2966 #[test]
2967 fn test_eq_dyn_neq_dyn_dictionary_to_boolean_array() {
2968 let test1 = vec![Some(true), None, Some(false)];
2969 let test2 = vec![Some(true), None, None, Some(true)];
2970
2971 let values = BooleanArray::from(test1);
2972 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2]);
2973 let dict_array = DictionaryArray::new(keys, Arc::new(values));
2974
2975 let array = BooleanArray::from(test2);
2976
2977 let result = crate::cmp::eq(&dict_array, &array);
2978 assert_eq!(
2979 result.unwrap(),
2980 BooleanArray::from(vec![Some(true), None, None, Some(false)])
2981 );
2982
2983 let result = crate::cmp::eq(&array, &dict_array);
2984 assert_eq!(
2985 result.unwrap(),
2986 BooleanArray::from(vec![Some(true), None, None, Some(false)])
2987 );
2988
2989 let result = crate::cmp::neq(&dict_array, &array);
2990 assert_eq!(
2991 result.unwrap(),
2992 BooleanArray::from(vec![Some(false), None, None, Some(true)])
2993 );
2994
2995 let result = crate::cmp::neq(&array, &dict_array);
2996 assert_eq!(
2997 result.unwrap(),
2998 BooleanArray::from(vec![Some(false), None, None, Some(true)])
2999 );
3000 }
3001
3002 #[test]
3003 fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_to_boolean_array() {
3004 let test1 = vec![Some(true), None, Some(false)];
3005 let test2 = vec![Some(true), None, None, Some(true)];
3006
3007 let values = BooleanArray::from(test1);
3008 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2]);
3009 let dict_array = DictionaryArray::new(keys, Arc::new(values));
3010
3011 let array = BooleanArray::from(test2);
3012
3013 let result = crate::cmp::lt(&dict_array, &array);
3014 assert_eq!(
3015 result.unwrap(),
3016 BooleanArray::from(vec![Some(false), None, None, Some(true)])
3017 );
3018
3019 let result = crate::cmp::lt(&array, &dict_array);
3020 assert_eq!(
3021 result.unwrap(),
3022 BooleanArray::from(vec![Some(false), None, None, Some(false)])
3023 );
3024
3025 let result = crate::cmp::lt_eq(&dict_array, &array);
3026 assert_eq!(
3027 result.unwrap(),
3028 BooleanArray::from(vec![Some(true), None, None, Some(true)])
3029 );
3030
3031 let result = crate::cmp::lt_eq(&array, &dict_array);
3032 assert_eq!(
3033 result.unwrap(),
3034 BooleanArray::from(vec![Some(true), None, None, Some(false)])
3035 );
3036
3037 let result = crate::cmp::gt(&dict_array, &array);
3038 assert_eq!(
3039 result.unwrap(),
3040 BooleanArray::from(vec![Some(false), None, None, Some(false)])
3041 );
3042
3043 let result = crate::cmp::gt(&array, &dict_array);
3044 assert_eq!(
3045 result.unwrap(),
3046 BooleanArray::from(vec![Some(false), None, None, Some(true)])
3047 );
3048
3049 let result = crate::cmp::gt_eq(&dict_array, &array);
3050 assert_eq!(
3051 result.unwrap(),
3052 BooleanArray::from(vec![Some(true), None, None, Some(false)])
3053 );
3054
3055 let result = crate::cmp::gt_eq(&array, &dict_array);
3056 assert_eq!(
3057 result.unwrap(),
3058 BooleanArray::from(vec![Some(true), None, None, Some(true)])
3059 );
3060 }
3061
3062 #[test]
3063 fn test_cmp_dict_decimal128() {
3064 let values = Decimal128Array::from_iter_values([0, 1, 2, 3, 4, 5]);
3065 let keys = Int8Array::from_iter_values([1_i8, 2, 5, 4, 3, 0]);
3066 let array1 = DictionaryArray::new(keys, Arc::new(values));
3067
3068 let values = Decimal128Array::from_iter_values([7, -3, 4, 3, 5]);
3069 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
3070 let array2 = DictionaryArray::new(keys, Arc::new(values));
3071
3072 let expected = BooleanArray::from(vec![false, false, false, true, true, false]);
3073 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
3074
3075 let expected = BooleanArray::from(vec![true, true, false, false, false, true]);
3076 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
3077
3078 let expected = BooleanArray::from(vec![true, true, false, true, true, true]);
3079 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
3080
3081 let expected = BooleanArray::from(vec![false, false, true, false, false, false]);
3082 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
3083
3084 let expected = BooleanArray::from(vec![false, false, true, true, true, false]);
3085 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
3086 }
3087
3088 #[test]
3089 fn test_cmp_dict_non_dict_decimal128() {
3090 let array1: Decimal128Array = Decimal128Array::from_iter_values([1, 2, 5, 4, 3, 0]);
3091
3092 let values = Decimal128Array::from_iter_values([7, -3, 4, 3, 5]);
3093 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
3094 let array2 = DictionaryArray::new(keys, Arc::new(values));
3095
3096 let expected = BooleanArray::from(vec![false, false, false, true, true, false]);
3097 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
3098
3099 let expected = BooleanArray::from(vec![true, true, false, false, false, true]);
3100 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
3101
3102 let expected = BooleanArray::from(vec![true, true, false, true, true, true]);
3103 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
3104
3105 let expected = BooleanArray::from(vec![false, false, true, false, false, false]);
3106 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
3107
3108 let expected = BooleanArray::from(vec![false, false, true, true, true, false]);
3109 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
3110 }
3111
3112 #[test]
3113 fn test_cmp_dict_decimal256() {
3114 let values =
3115 Decimal256Array::from_iter_values([0, 1, 2, 3, 4, 5].into_iter().map(i256::from_i128));
3116 let keys = Int8Array::from_iter_values([1_i8, 2, 5, 4, 3, 0]);
3117 let array1 = DictionaryArray::new(keys, Arc::new(values));
3118
3119 let values =
3120 Decimal256Array::from_iter_values([7, -3, 4, 3, 5].into_iter().map(i256::from_i128));
3121 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
3122 let array2 = DictionaryArray::new(keys, Arc::new(values));
3123
3124 let expected = BooleanArray::from(vec![false, false, false, true, true, false]);
3125 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
3126
3127 let expected = BooleanArray::from(vec![true, true, false, false, false, true]);
3128 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
3129
3130 let expected = BooleanArray::from(vec![true, true, false, true, true, true]);
3131 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
3132
3133 let expected = BooleanArray::from(vec![false, false, true, false, false, false]);
3134 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
3135
3136 let expected = BooleanArray::from(vec![false, false, true, true, true, false]);
3137 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
3138 }
3139
3140 #[test]
3141 fn test_cmp_dict_non_dict_decimal256() {
3142 let array1: Decimal256Array =
3143 Decimal256Array::from_iter_values([1, 2, 5, 4, 3, 0].into_iter().map(i256::from_i128));
3144
3145 let values =
3146 Decimal256Array::from_iter_values([7, -3, 4, 3, 5].into_iter().map(i256::from_i128));
3147 let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
3148 let array2 = DictionaryArray::new(keys, Arc::new(values));
3149
3150 let expected = BooleanArray::from(vec![false, false, false, true, true, false]);
3151 assert_eq!(crate::cmp::eq(&array1, &array2).unwrap(), expected);
3152
3153 let expected = BooleanArray::from(vec![true, true, false, false, false, true]);
3154 assert_eq!(crate::cmp::lt(&array1, &array2).unwrap(), expected);
3155
3156 let expected = BooleanArray::from(vec![true, true, false, true, true, true]);
3157 assert_eq!(crate::cmp::lt_eq(&array1, &array2).unwrap(), expected);
3158
3159 let expected = BooleanArray::from(vec![false, false, true, false, false, false]);
3160 assert_eq!(crate::cmp::gt(&array1, &array2).unwrap(), expected);
3161
3162 let expected = BooleanArray::from(vec![false, false, true, true, true, false]);
3163 assert_eq!(crate::cmp::gt_eq(&array1, &array2).unwrap(), expected);
3164 }
3165
3166 #[test]
3167 fn test_decimal128() {
3168 let a = Decimal128Array::from_iter_values([1, 2, 4, 5]);
3169 let b = Decimal128Array::from_iter_values([7, -3, 4, 3]);
3170 let e = BooleanArray::from(vec![false, false, true, false]);
3171 let r = crate::cmp::eq(&a, &b).unwrap();
3172 assert_eq!(e, r);
3173
3174 let e = BooleanArray::from(vec![true, false, false, false]);
3175 let r = crate::cmp::lt(&a, &b).unwrap();
3176 assert_eq!(e, r);
3177
3178 let e = BooleanArray::from(vec![true, false, true, false]);
3179 let r = crate::cmp::lt_eq(&a, &b).unwrap();
3180 assert_eq!(e, r);
3181
3182 let e = BooleanArray::from(vec![false, true, false, true]);
3183 let r = crate::cmp::gt(&a, &b).unwrap();
3184 assert_eq!(e, r);
3185
3186 let e = BooleanArray::from(vec![false, true, true, true]);
3187 let r = crate::cmp::gt_eq(&a, &b).unwrap();
3188 assert_eq!(e, r);
3189 }
3190
3191 #[test]
3192 fn test_decimal128_scalar() {
3193 let a = Decimal128Array::from(vec![Some(1), Some(2), Some(3), None, Some(4), Some(5)]);
3194 let b = Decimal128Array::new_scalar(3_i128);
3195 let e = BooleanArray::from(
3197 vec![Some(false), Some(false), Some(true), None, Some(false), Some(false)],
3198 );
3199 let r = crate::cmp::eq(&a, &b).unwrap();
3200 assert_eq!(e, r);
3201
3202 let e = BooleanArray::from(
3204 vec![Some(true), Some(true), Some(false), None, Some(true), Some(true)],
3205 );
3206 let r = crate::cmp::neq(&a, &b).unwrap();
3207 assert_eq!(e, r);
3208
3209 let e = BooleanArray::from(
3211 vec![Some(true), Some(true), Some(false), None, Some(false), Some(false)],
3212 );
3213 let r = crate::cmp::lt(&a, &b).unwrap();
3214 assert_eq!(e, r);
3215
3216 let e = BooleanArray::from(
3218 vec![Some(true), Some(true), Some(true), None, Some(false), Some(false)],
3219 );
3220 let r = crate::cmp::lt_eq(&a, &b).unwrap();
3221 assert_eq!(e, r);
3222
3223 let e = BooleanArray::from(
3225 vec![Some(false), Some(false), Some(false), None, Some(true), Some(true)],
3226 );
3227 let r = crate::cmp::gt(&a, &b).unwrap();
3228 assert_eq!(e, r);
3229
3230 let e = BooleanArray::from(
3232 vec![Some(false), Some(false), Some(true), None, Some(true), Some(true)],
3233 );
3234 let r = crate::cmp::gt_eq(&a, &b).unwrap();
3235 assert_eq!(e, r);
3236 }
3237
3238 #[test]
3239 fn test_decimal256() {
3240 let a = Decimal256Array::from_iter_values([1, 2, 4, 5].into_iter().map(i256::from_i128));
3241 let b = Decimal256Array::from_iter_values([7, -3, 4, 3].into_iter().map(i256::from_i128));
3242 let e = BooleanArray::from(vec![false, false, true, false]);
3243 let r = crate::cmp::eq(&a, &b).unwrap();
3244 assert_eq!(e, r);
3245
3246 let e = BooleanArray::from(vec![true, false, false, false]);
3247 let r = crate::cmp::lt(&a, &b).unwrap();
3248 assert_eq!(e, r);
3249
3250 let e = BooleanArray::from(vec![true, false, true, false]);
3251 let r = crate::cmp::lt_eq(&a, &b).unwrap();
3252 assert_eq!(e, r);
3253
3254 let e = BooleanArray::from(vec![false, true, false, true]);
3255 let r = crate::cmp::gt(&a, &b).unwrap();
3256 assert_eq!(e, r);
3257
3258 let e = BooleanArray::from(vec![false, true, true, true]);
3259 let r = crate::cmp::gt_eq(&a, &b).unwrap();
3260 assert_eq!(e, r);
3261 }
3262
3263 #[test]
3264 fn test_decimal256_scalar_i128() {
3265 let a = Decimal256Array::from_iter_values([1, 2, 3, 4, 5].into_iter().map(i256::from_i128));
3266 let b = Decimal256Array::new_scalar(i256::from_i128(3));
3267 let e = BooleanArray::from(vec![false, false, true, false, false]);
3269 let r = crate::cmp::eq(&a, &b).unwrap();
3270 assert_eq!(e, r);
3271
3272 let e = BooleanArray::from(vec![true, true, false, true, true]);
3274 let r = crate::cmp::neq(&a, &b).unwrap();
3275 assert_eq!(e, r);
3276
3277 let e = BooleanArray::from(vec![true, true, false, false, false]);
3279 let r = crate::cmp::lt(&a, &b).unwrap();
3280 assert_eq!(e, r);
3281
3282 let e = BooleanArray::from(vec![true, true, true, false, false]);
3284 let r = crate::cmp::lt_eq(&a, &b).unwrap();
3285 assert_eq!(e, r);
3286
3287 let e = BooleanArray::from(vec![false, false, false, true, true]);
3289 let r = crate::cmp::gt(&a, &b).unwrap();
3290 assert_eq!(e, r);
3291
3292 let e = BooleanArray::from(vec![false, false, true, true, true]);
3294 let r = crate::cmp::gt_eq(&a, &b).unwrap();
3295 assert_eq!(e, r);
3296 }
3297
3298 #[test]
3299 fn test_decimal256_scalar_i256() {
3300 let a = Decimal256Array::from_iter_values([1, 2, 3, 4, 5].into_iter().map(i256::from_i128));
3301 let b = Decimal256Array::new_scalar(i256::MAX);
3302 let e = BooleanArray::from(vec![false, false, false, false, false]);
3304 let r = crate::cmp::eq(&a, &b).unwrap();
3305 assert_eq!(e, r);
3306
3307 let e = BooleanArray::from(vec![true, true, true, true, true]);
3309 let r = crate::cmp::neq(&a, &b).unwrap();
3310 assert_eq!(e, r);
3311
3312 let e = BooleanArray::from(vec![true, true, true, true, true]);
3314 let r = crate::cmp::lt(&a, &b).unwrap();
3315 assert_eq!(e, r);
3316
3317 let e = BooleanArray::from(vec![true, true, true, true, true]);
3319 let r = crate::cmp::lt_eq(&a, &b).unwrap();
3320 assert_eq!(e, r);
3321
3322 let e = BooleanArray::from(vec![false, false, false, false, false]);
3324 let r = crate::cmp::gt(&a, &b).unwrap();
3325 assert_eq!(e, r);
3326
3327 let e = BooleanArray::from(vec![false, false, false, false, false]);
3329 let r = crate::cmp::gt_eq(&a, &b).unwrap();
3330 assert_eq!(e, r);
3331 }
3332
3333 #[test]
3334 fn test_floating_zeros() {
3335 let a = Float32Array::from(vec![0.0_f32, -0.0]);
3336 let b = Float32Array::from(vec![-0.0_f32, 0.0]);
3337
3338 let result = crate::cmp::eq(&a, &b).unwrap();
3339 let excepted = BooleanArray::from(vec![false, false]);
3340 assert_eq!(excepted, result);
3341
3342 let scalar = Float32Array::new_scalar(0.0);
3343 let result = crate::cmp::eq(&a, &scalar).unwrap();
3344 let excepted = BooleanArray::from(vec![true, false]);
3345 assert_eq!(excepted, result);
3346
3347 let scalar = Float32Array::new_scalar(-0.0);
3348 let result = crate::cmp::eq(&a, &scalar).unwrap();
3349 let excepted = BooleanArray::from(vec![false, true]);
3350 assert_eq!(excepted, result);
3351 }
3352
3353 #[test]
3354 fn test_dictionary_nested_nulls() {
3355 let keys = Int32Array::from(vec![0, 1, 2]);
3356 let v1 = Arc::new(Int32Array::from(vec![Some(0), None, Some(2)]));
3357 let a = DictionaryArray::new(keys.clone(), v1);
3358 let v2 = Arc::new(Int32Array::from(vec![None, Some(0), Some(2)]));
3359 let b = DictionaryArray::new(keys, v2);
3360
3361 let r = crate::cmp::eq(&a, &b).unwrap();
3362 assert_eq!(r.null_count(), 2);
3363 assert!(r.is_valid(2));
3364 }
3365}