test unsupported case

Author: davidhewitt

arrow-select/src/concat.rs

@@ -121,7 +121,8 @@ fn concat_dictionaries<K: ArrowDictionaryKeyType>(
         // to concatenating values
         _ if !is_overflow => concat_fallback(arrays, Capacities::Array(output_len)),
         other => Err(ArrowError::NotYetImplemented(format!(
-            "concat of dictionaries would overflow key type {key_type:?} with value type {other:?}",
+            "concat of dictionaries would overflow key type {key_type:?} and \
+             value type {other:?} not yet supported for merging",
             key_type = K::DATA_TYPE,
         )))
     }
@@ -1021,6 +1022,33 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_unsupported_concat_dictionary_overflow() {
+        // each array has length equal to the full dictionary key space
+        let len: usize = usize::try_from(i8::MAX).unwrap();
+
+        let a = DictionaryArray::<Int8Type>::new(
+            Int8Array::from_value(0, len),
+            Arc::new(NullArray::new(len)),
+        );
+        let b = DictionaryArray::<Int8Type>::new(
+            Int8Array::from_value(0, len),
+            Arc::new(NullArray::new(len)),
+        );
+
+        // Case 1: with a single input array, should _never_ overflow
+        concat(&[&a]).unwrap();
+
+        // Case 2: two arrays
+        // Will fail to merge values on unsupported datatype
+        let values = concat(&[&a, &b]).unwrap_err();
+        assert_eq!(
+            values.to_string(),
+            "Not yet implemented: concat of dictionaries would overflow key type Int8 and \
+             value type Null not yet supported for merging"
+        );
+    }
+
     #[test]
     fn test_concat_string_sizes() {
         let a: LargeStringArray = ((0..150).map(|_| Some("foo"))).collect();

arrow-select/src/interleave.rs

@@ -223,7 +223,8 @@ fn interleave_dictionaries<K: ArrowDictionaryKeyType>(
         // to concatenating values
         _ if !is_overflow => interleave_fallback(arrays, indices),
         other => Err(ArrowError::NotYetImplemented(format!(
-            "interleave of dictionaries would overflow key type {key_type:?} with value type {other:?}",
+            "interleave of dictionaries would overflow key type {key_type:?} and \
+             value type {other:?} not yet supported for merging",
             key_type = K::DATA_TYPE,
         )))
     }
@@ -547,6 +548,33 @@ mod tests {
         assert_eq!(&collected, &[0, 0, 1]);
     }
 
+    #[test]
+    fn test_unsupported_interleave_dictionary_overflow() {
+        // each array has length equal to the full dictionary key space
+        let len: usize = usize::try_from(i8::MAX).unwrap();
+
+        let a = DictionaryArray::<Int8Type>::new(
+            Int8Array::from_value(0, len),
+            Arc::new(NullArray::new(len)),
+        );
+        let b = DictionaryArray::<Int8Type>::new(
+            Int8Array::from_value(0, len),
+            Arc::new(NullArray::new(len)),
+        );
+
+        // Case 1: with a single input array, should _never_ overflow
+        interleave(&[&a], &[(0, 2), (0, 2)]).unwrap();
+
+        // Case 2: two arrays
+        // Will fail to merge values on unsupported datatype
+        let values = interleave(&[&a, &b], &[(0, 2), (0, 2), (1, 1)]).unwrap_err();
+        assert_eq!(
+            values.to_string(),
+            "Not yet implemented: qinterleave of dictionaries would overflow key type Int8 and \
+             value type Null not yet supported for merging"
+        );
+    }
+
     #[test]
     fn test_lists() {
         // [[1, 2], null, [3]]