Allow to compare bool and int

Author: ilya-biryukov

datafusion/src/physical_plan/expressions/binary.rs

@@ -50,6 +50,7 @@ use crate::scalar::ScalarValue;
 
 use super::coercion::{eq_coercion, numerical_coercion, order_coercion, string_coercion};
 use crate::physical_plan::expressions::coercion::{is_numeric, string_implicit_cast};
+use arrow::compute::{eq_bool, neq_bool};
 
 /// Binary expression
 #[derive(Debug)]
@@ -659,6 +660,28 @@ impl PhysicalExpr for BinaryExpr {
             right_value.into_array(batch.num_rows()),
         );
 
+        // Handle boolean comparisons.
+        if left.data_type() == &DataType::Boolean {
+            let boolean_eq = |is_eq: bool| {
+                let left = left.as_any().downcast_ref::<BooleanArray>().unwrap();
+                let right = right.as_any().downcast_ref::<BooleanArray>().unwrap();
+                if is_eq {
+                    eq_bool(left, right)
+                } else {
+                    neq_bool(left, right)
+                }
+            };
+            match self.op {
+                Operator::Eq => {
+                    return Ok(ColumnarValue::Array(Arc::new(boolean_eq(true)?)))
+                }
+                Operator::NotEq => {
+                    return Ok(ColumnarValue::Array(Arc::new(boolean_eq(false)?)))
+                }
+                _ => {}
+            }
+        }
+
         let result: Result<ArrayRef> = match &self.op {
             Operator::Like => binary_string_array_op!(left, right, like),
             Operator::NotLike => binary_string_array_op!(left, right, nlike),

datafusion/src/physical_plan/expressions/coercion.rs

@@ -241,11 +241,20 @@ pub fn eq_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType>
         return Some(lhs_type.clone());
     }
     numerical_coercion(lhs_type, rhs_type)
+        .or_else(|| eq_bool_coercion(lhs_type, rhs_type))
         .or_else(|| dictionary_coercion(lhs_type, rhs_type))
         .or_else(|| temporal_coercion(lhs_type, rhs_type))
         .or_else(|| string_implicit_cast(lhs_type, rhs_type))
 }
 
+fn eq_bool_coercion(l: &DataType, r: &DataType) -> Option<DataType> {
+    if l == &DataType::Boolean || r == &DataType::Boolean {
+        Some(DataType::Boolean)
+    } else {
+        None
+    }
+}
+
 // coercion rules that assume an ordered set, such as "less than".
 // These are the union of all numerical coercion rules and all string coercion rules
 pub fn order_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {