@@ -23,23 +23,22 @@ use arrow::compute::kernels::arithmetic::{
2323    add,  divide,  divide_scalar,  modulus,  modulus_scalar,  multiply,  subtract, 
2424} ; 
2525use  arrow:: compute:: kernels:: boolean:: { and_kleene,  not,  or_kleene} ; 
26- use  arrow:: compute:: kernels:: comparison:: { eq,  gt,  gt_eq,  lt,  lt_eq,  neq} ; 
2726use  arrow:: compute:: kernels:: comparison:: { 
28-     eq_bool ,   eq_bool_scalar,  gt_bool ,  gt_bool_scalar ,  gt_eq_bool ,  gt_eq_bool_scalar , 
29-     lt_bool ,  lt_bool_scalar ,  lt_eq_bool ,  lt_eq_bool_scalar ,  neq_bool ,   neq_bool_scalar, 
27+     eq_bool_scalar,  gt_bool_scalar ,  gt_eq_bool_scalar ,  lt_bool_scalar ,  lt_eq_bool_scalar , 
28+     neq_bool_scalar, 
3029} ; 
3130use  arrow:: compute:: kernels:: comparison:: { 
32-     eq_scalar ,  gt_eq_scalar ,  gt_scalar ,  lt_eq_scalar ,  lt_scalar ,  neq_scalar , 
31+     eq_dyn ,  gt_dyn ,  gt_eq_dyn ,  lt_dyn ,  lt_eq_dyn ,  neq_dyn , 
3332} ; 
3433use  arrow:: compute:: kernels:: comparison:: { 
35-     eq_utf8,  gt_eq_utf8,  gt_utf8,  like_utf8,  lt_eq_utf8,  lt_utf8,  neq_utf8,  nlike_utf8, 
36-     regexp_is_match_utf8, 
34+     eq_scalar,  gt_eq_scalar,  gt_scalar,  lt_eq_scalar,  lt_scalar,  neq_scalar, 
3735} ; 
3836use  arrow:: compute:: kernels:: comparison:: { 
3937    eq_utf8_scalar,  gt_eq_utf8_scalar,  gt_utf8_scalar,  like_utf8_scalar, 
4038    lt_eq_utf8_scalar,  lt_utf8_scalar,  neq_utf8_scalar,  nlike_utf8_scalar, 
4139    regexp_is_match_utf8_scalar, 
4240} ; 
41+ use  arrow:: compute:: kernels:: comparison:: { like_utf8,  nlike_utf8,  regexp_is_match_utf8} ; 
4342use  arrow:: datatypes:: { ArrowNumericType ,  DataType ,  Schema ,  TimeUnit } ; 
4443use  arrow:: record_batch:: RecordBatch ; 
4544
@@ -561,6 +560,17 @@ macro_rules! binary_array_op_scalar {
561560    } } ; 
562561} 
563562
563+ /// Calls a dynamic comparison operation from Arrow and converts the 
564+ /// error and return type appropriately 
565+ fn  call_dyn_cmp < F > ( left :  Arc < dyn  Array > ,  right :  Arc < dyn  Array > ,  f :  F )  -> Result < ArrayRef > 
566+ where 
567+     F :  Fn ( & dyn  Array ,  & dyn  Array )  -> arrow:: error:: Result < BooleanArray > , 
568+ { 
569+     f ( left. as_ref ( ) ,  right. as_ref ( ) ) 
570+         . map ( |a| Arc :: new ( a)  as  ArrayRef ) 
571+         . map_err ( |e| e. into ( ) ) 
572+ } 
573+ 
564574/// The binary_array_op macro includes types that extend beyond the primitive, 
565575/// such as Utf8 strings. 
566576#[ macro_export]  
@@ -904,12 +914,12 @@ impl BinaryExpr {
904914        match  & self . op  { 
905915            Operator :: Like  => binary_string_array_op ! ( left,  right,  like) , 
906916            Operator :: NotLike  => binary_string_array_op ! ( left,  right,  nlike) , 
907-             Operator :: Lt  => binary_array_op ! ( left,  right,  lt ) , 
908-             Operator :: LtEq  => binary_array_op ! ( left,  right,  lt_eq ) , 
909-             Operator :: Gt  => binary_array_op ! ( left,  right,  gt ) , 
910-             Operator :: GtEq  => binary_array_op ! ( left,  right,  gt_eq ) , 
911-             Operator :: Eq  => binary_array_op ! ( left,  right,  eq ) , 
912-             Operator :: NotEq  => binary_array_op ! ( left,  right,  neq ) , 
917+             Operator :: Lt  => call_dyn_cmp ( left,  right,  lt_dyn ) , 
918+             Operator :: LtEq  => call_dyn_cmp ( left,  right,  lt_eq_dyn ) , 
919+             Operator :: Gt  => call_dyn_cmp ( left,  right,  gt_dyn ) , 
920+             Operator :: GtEq  => call_dyn_cmp ( left,  right,  gt_eq_dyn ) , 
921+             Operator :: Eq  => call_dyn_cmp ( left,  right,  eq_dyn ) , 
922+             Operator :: NotEq  => call_dyn_cmp ( left,  right,  neq_dyn ) , 
913923            Operator :: IsDistinctFrom  => binary_array_op ! ( left,  right,  is_distinct_from) , 
914924            Operator :: IsNotDistinctFrom  => { 
915925                binary_array_op ! ( left,  right,  is_not_distinct_from) 
0 commit comments