arrow_ord/
comparison.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18//! Comparison kernels for `Array`s.
19//!
20//! These kernels can leverage SIMD if available on your system.  Currently no runtime
21//! detection is provided, you should enable the specific SIMD intrinsics using
22//! `RUSTFLAGS="-C target-feature=+avx2"` for example.  See the documentation
23//! [here](https://doc.rust-lang.org/stable/core/arch/) for more information.
24//!
25
26use arrow_array::cast::*;
27
28use arrow_array::*;
29use arrow_buffer::{bit_util, BooleanBuffer, MutableBuffer, NullBuffer};
30use arrow_schema::ArrowError;
31
32/// Checks if a [`GenericListArray`] contains a value in the [`PrimitiveArray`]
33pub 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    // if both array slots are valid, check if list contains primitive
55    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
73/// Checks if a [`GenericListArray`] contains a value in the [`GenericStringArray`]
74pub 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        // contains(null, null) = false
96        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// disable wrapping inside literal vectors used for test data and assertions
113#[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    /// Evaluate `KERNEL` with two vectors as inputs and assert against the expected output.
130    /// `A_VEC` and `B_VEC` can be of type `Vec<T>` or `Vec<Option<T>>` where `T` is the native
131    /// type of the data type of the Arrow array element.
132    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
133    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
134    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            // slice and test if still works
142            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            // test with a larger version of the same data to ensure we cover the chunked part of the comparison
148            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    /// Evaluate `KERNEL` with two vectors as inputs and assert against the expected output.
164    /// `A_VEC` and `B_VEC` can be of type `Vec<i64>` or `Vec<Option<i64>>`.
165    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
166    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
167    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    /// Evaluate `KERNEL` with one vectors and one scalar as inputs and assert against the expected output.
174    /// `A_VEC` can be of type `Vec<i64>` or `Vec<Option<i64>>`.
175    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
176    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
177    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            // test with a larger version of the same data to ensure we cover the chunked part of the comparison
185            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                // 1 year
254                IntervalYearMonthType::make_value(1, 0),
255            ],
256            vec![
257                IntervalYearMonthType::make_value(1, 2),
258                IntervalYearMonthType::make_value(1, 2),
259                // NB 12 months is treated as equal to a year (as the underlying
260                // type stores number of months)
261                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                // 1 month
273                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                // 30 days is not treated as a month
280                IntervalMonthDayNanoType::make_value(0, 30, 0),
281                // 100 days
282                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                // 90M milliseconds
549                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                // NB even though 1 day is less than 90M milliseconds long,
557                // it compares as greater because the underlying type stores
558                // days and milliseconds as different fields
559                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                // 1 year
572                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                // NB 12 months is treated as equal to a year (as the underlying
579                // type stores number of months)
580                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                // 1 month
592                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                // 30 days is not treated as a month
601                IntervalMonthDayNanoType::make_value(0, 30, 0),
602                // 100 days (note is treated as greater than 1 month as the underlying integer representation)
603                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        // `item_count` is chosen to not be a multiple of the number of SIMD lanes for this
791        // type (`Int8Type`), 64.
792        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    // Expected behaviour:
804    // contains(1, [1, 2, null]) = true
805    // contains(3, [1, 2, null]) = false
806    // contains(null, [1, 2, null]) = false
807    // contains(null, null) = false
808    #[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        //  [[0, 1, 2], [3, 4, 5], null, [6, null, 7]]
834        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    // Expected behaviour:
1058    // contains("ab", ["ab", "cd", null]) = true
1059    // contains("ef", ["ab", "cd", null]) = false
1060    // contains(null, ["ab", "cd", null]) = false
1061    // contains(null, null) = false
1062    #[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        //  [["Lorem", "ipsum", null], ["sit", "amet", "Lorem"], null, ["ipsum"]]
1080        // value_offsets = [0, 3, 6, 6]
1081        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    /// Below are two carefully crafted arrays that compares:
1238    /// (1) 2 large strings that have the same first 4 bytes but are different in the remaining bytes
1239    /// (2) 1 large and 1 small string that are the same in the first 4 bytes but different in the remaining bytes
1240    /// (3) 2 small strings that are the same in the first 4 byes
1241    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        // Construct a value array
2165        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        // Construct a value array
2321        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        // array eq scalar
3196        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        // array neq scalar
3203        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        // array lt scalar
3210        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        // array lt_eq scalar
3217        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        // array gt scalar
3224        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        // array gt_eq scalar
3231        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        // array eq scalar
3268        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        // array neq scalar
3273        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        // array lt scalar
3278        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        // array lt_eq scalar
3283        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        // array gt scalar
3288        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        // array gt_eq scalar
3293        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        // array eq scalar
3303        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        // array neq scalar
3308        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        // array lt scalar
3313        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        // array lt_eq scalar
3318        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        // array gt scalar
3323        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        // array gt_eq scalar
3328        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}