Support concatenation of mixed FixedSizeBinary types without conversion to Binary

Author: pepijnve

datafusion/expr-common/src/type_coercion/binary.rs

@@ -237,7 +237,7 @@ impl<'a> BinaryTypeCoercer<'a> {
             })
         }
         StringConcat => {
-            string_concat_coercion(lhs, rhs).map(Signature::uniform).ok_or_else(|| {
+            string_concat_coercion(lhs, rhs).ok_or_else(|| {
                 plan_datafusion_err!(
                     "Cannot infer common string type for string concat operation {} {} {}", self.lhs, self.op, self.rhs
                 )
@@ -1635,50 +1635,63 @@ fn ree_coercion(
 /// 1. At least one side of lhs and rhs should be string type (Utf8 / LargeUtf8)
 /// 2. Data type of the other side should be able to cast to string type
 /// 3. Binary and string types cannot be mixed
-fn string_concat_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {
+fn string_concat_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<Signature> {
     use arrow::datatypes::DataType::*;
-    string_coercion(lhs_type, rhs_type).or_else(|| match (lhs_type, rhs_type) {
-        // Allow pure binary + binary
-        (
-            Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
-            Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
-        ) => {
-            // Coerce fixed-sized binary to variable-sized `Binary` to make uniform signature
-            // with the `Binary` result
-            let lhs_type = match lhs_type {
-                FixedSizeBinary(_) => &Binary,
-                val => val,
-            };
-            let rhs_type = match rhs_type {
-                FixedSizeBinary(_) => &Binary,
-                val => val,
-            };
-            binary_coercion(lhs_type, rhs_type)
-        }
-        // Deny other mixed binary + string combinations
-        (
-            Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
-            Utf8 | LargeUtf8 | Utf8View,
-        ) => None,
-        (
-            Utf8 | LargeUtf8 | Utf8View,
-            Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
-        ) => None,
-        // Predicate-based coercion rules are following
-        (Utf8View, from_type) | (from_type, Utf8View) => {
-            string_concat_internal_coercion(from_type, &Utf8View)
-        }
-        (Utf8, from_type) | (from_type, Utf8) => {
-            string_concat_internal_coercion(from_type, &Utf8)
-        }
-        (LargeUtf8, from_type) | (from_type, LargeUtf8) => {
-            string_concat_internal_coercion(from_type, &LargeUtf8)
-        }
-        (Dictionary(_, lhs_value_type), Dictionary(_, rhs_value_type)) => {
-            string_coercion(lhs_value_type, rhs_value_type).or(None)
-        }
-        _ => None,
-    })
+
+    string_coercion(lhs_type, rhs_type)
+        .map(Signature::uniform)
+        .or_else(|| match (lhs_type, rhs_type) {
+            // Allow concatenation of mixed fixed size binary
+            (FixedSizeBinary(l), FixedSizeBinary(r)) => Some(Signature {
+                lhs: lhs_type.clone(),
+                rhs: rhs_type.clone(),
+                ret: FixedSizeBinary(l + r),
+            }),
+            // Allow pure binary + binary
+            (
+                Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
+                Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
+            ) => {
+                // Coerce fixed-sized binary to variable-sized `Binary` to make uniform signature
+                // with the `Binary` result
+                let lhs_type = match lhs_type {
+                    FixedSizeBinary(_) => &Binary,
+                    val => val,
+                };
+                let rhs_type = match rhs_type {
+                    FixedSizeBinary(_) => &Binary,
+                    val => val,
+                };
+                binary_coercion(lhs_type, rhs_type).map(Signature::uniform)
+            }
+            // Deny other mixed binary + string combinations
+            (
+                Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
+                Utf8 | LargeUtf8 | Utf8View,
+            ) => None,
+            (
+                Utf8 | LargeUtf8 | Utf8View,
+                Binary | LargeBinary | BinaryView | FixedSizeBinary(_),
+            ) => None,
+            // Predicate-based coercion rules are following
+            (Utf8View, from_type) | (from_type, Utf8View) => {
+                string_concat_internal_coercion(from_type, &Utf8View)
+                    .map(Signature::uniform)
+            }
+            (Utf8, from_type) | (from_type, Utf8) => {
+                string_concat_internal_coercion(from_type, &Utf8).map(Signature::uniform)
+            }
+            (LargeUtf8, from_type) | (from_type, LargeUtf8) => {
+                string_concat_internal_coercion(from_type, &LargeUtf8)
+                    .map(Signature::uniform)
+            }
+            (Dictionary(_, lhs_value_type), Dictionary(_, rhs_value_type)) => {
+                string_coercion(lhs_value_type, rhs_value_type)
+                    .or(None)
+                    .map(Signature::uniform)
+            }
+            _ => None,
+        })
 }
 
 fn array_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option<DataType> {