Implement DeserializeValue for Box<str> and Arc<str>

Author: Lorak-mmk

scylla-cql/src/deserialize/value.rs

@@ -1560,6 +1560,41 @@ impl<'frame, 'metadata, T: DeserializeValue<'frame, 'metadata>> DeserializeValue
     }
 }
 
+// Special cases for Box<str> and Arc<str>
+// The generic implementations above don't work for str. This is because
+// DeserializeValue is implemented for &str, but not for str. We can't change this:
+// the type for DeserializeValue must be Sized because it is returned from deserialize method.
+
+impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for Box<str> {
+    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
+        <String as DeserializeValue>::type_check(typ).map_err(typck_error_replace_rust_name::<Self>)
+    }
+
+    fn deserialize(
+        typ: &'metadata ColumnType<'metadata>,
+        v: Option<FrameSlice<'frame>>,
+    ) -> Result<Self, DeserializationError> {
+        String::deserialize(typ, v)
+            .map(String::into_boxed_str)
+            .map_err(deser_error_replace_rust_name::<Self>)
+    }
+}
+
+impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for Arc<str> {
+    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
+        <&str as DeserializeValue>::type_check(typ).map_err(typck_error_replace_rust_name::<Self>)
+    }
+
+    fn deserialize(
+        typ: &'metadata ColumnType<'metadata>,
+        v: Option<FrameSlice<'frame>>,
+    ) -> Result<Self, DeserializationError> {
+        <&str as DeserializeValue>::deserialize(typ, v)
+            .map(Into::<Arc<str>>::into)
+            .map_err(deser_error_replace_rust_name::<Self>)
+    }
+}
+
 // Utilities
 
 fn ensure_not_null_frame_slice<'frame, T>(

scylla-cql/src/deserialize/value_tests.rs

@@ -1159,18 +1159,36 @@ fn test_tuples() {
 
 #[test]
 fn test_box() {
-    let int = make_bytes(&[0x01, 0x02, 0x03, 0x04]);
-    let decoded_int: Box<i32> =
-        deserialize::<Box<i32>>(&ColumnType::Native(NativeType::Int), &int).unwrap();
-    assert_eq!(*decoded_int, 0x01020304);
+    {
+        let int = make_bytes(&[0x01, 0x02, 0x03, 0x04]);
+        let decoded_int: Box<i32> =
+            deserialize::<Box<i32>>(&ColumnType::Native(NativeType::Int), &int).unwrap();
+        assert_eq!(*decoded_int, 0x01020304);
+    }
+
+    {
+        let text_bytes = make_bytes(b"abcd");
+        let decoded_int: Box<str> =
+            deserialize::<Box<str>>(&ColumnType::Native(NativeType::Text), &text_bytes).unwrap();
+        assert_eq!(&*decoded_int, "abcd");
+    }
 }
 
 #[test]
 fn test_arc() {
-    let int = make_bytes(&[0x01, 0x02, 0x03, 0x04]);
-    let decoded_int: Arc<i32> =
-        deserialize::<Arc<i32>>(&ColumnType::Native(NativeType::Int), &int).unwrap();
-    assert_eq!(*decoded_int, 0x01020304);
+    {
+        let int = make_bytes(&[0x01, 0x02, 0x03, 0x04]);
+        let decoded_int: Arc<i32> =
+            deserialize::<Arc<i32>>(&ColumnType::Native(NativeType::Int), &int).unwrap();
+        assert_eq!(*decoded_int, 0x01020304);
+    }
+
+    {
+        let text_bytes = make_bytes(b"abcd");
+        let decoded_int: Arc<str> =
+            deserialize::<Arc<str>>(&ColumnType::Native(NativeType::Text), &text_bytes).unwrap();
+        assert_eq!(&*decoded_int, "abcd");
+    }
 }
 
 pub(crate) fn udt_def_with_fields(
@@ -2489,6 +2507,30 @@ fn test_box_errors() {
             got: 4,
         }
     );
+
+    // Arc<str> is a special case, let's test it separately
+    assert_type_check_error!(
+        &bytes,
+        Box<str>,
+        ColumnType::Native(NativeType::Int),
+        BuiltinTypeCheckErrorKind::MismatchedType {
+            expected: &[
+                ColumnType::Native(NativeType::Ascii),
+                ColumnType::Native(NativeType::Text)
+            ],
+        }
+    );
+
+    // -126 is not a valid ASCII nor UTF-8 byte.
+    let v = -126_i8;
+    let bytes = serialize(&ColumnType::Native(NativeType::TinyInt), &v);
+
+    assert_deser_error!(
+        &bytes,
+        Box<str>,
+        ColumnType::Native(NativeType::Text),
+        BuiltinDeserializationErrorKind::InvalidUtf8(_)
+    );
 }
 
 #[test]
@@ -2516,6 +2558,30 @@ fn test_arc_errors() {
             got: 4,
         }
     );
+
+    // Arc<str> is a special case, let's test it separately
+    assert_type_check_error!(
+        &bytes,
+        Arc<str>,
+        ColumnType::Native(NativeType::Int),
+        BuiltinTypeCheckErrorKind::MismatchedType {
+            expected: &[
+                ColumnType::Native(NativeType::Ascii),
+                ColumnType::Native(NativeType::Text)
+            ],
+        }
+    );
+
+    // -126 is not a valid ASCII nor UTF-8 byte.
+    let v = -126_i8;
+    let bytes = serialize(&ColumnType::Native(NativeType::TinyInt), &v);
+
+    assert_deser_error!(
+        &bytes,
+        Arc<str>,
+        ColumnType::Native(NativeType::Text),
+        BuiltinDeserializationErrorKind::InvalidUtf8(_)
+    );
 }
 
 #[test]