ser: udt

Author: muzarski

scylla-rust-wrapper/src/value.rs

@@ -1,4 +1,4 @@
-use std::{convert::TryInto, net::IpAddr};
+use std::{collections::HashMap, convert::TryInto, net::IpAddr};
 
 use scylla::{
     frame::{response::result::ColumnType, value::CqlDate},
@@ -7,7 +7,8 @@ use scylla::{
             BuiltinSerializationError, BuiltinSerializationErrorKind, BuiltinTypeCheckError,
             BuiltinTypeCheckErrorKind, MapSerializationErrorKind, MapTypeCheckErrorKind,
             SerializeCql, SetOrListSerializationErrorKind, SetOrListTypeCheckErrorKind,
-            TupleSerializationErrorKind, TupleTypeCheckErrorKind,
+            TupleSerializationErrorKind, TupleTypeCheckErrorKind, UdtSerializationErrorKind,
+            UdtTypeCheckErrorKind,
         },
         writers::WrittenCellProof,
         CellWriter, SerializationError,
@@ -108,7 +109,7 @@ impl SerializeCql for CassCqlValue {
                 keyspace,
                 type_name,
                 fields,
-            } => todo!(),
+            } => serialize_udt(typ, keyspace, type_name, fields, writer),
         }
     }
 }
@@ -357,3 +358,79 @@ fn serialize_mapping<'t, 'b, K: SerializeCql + 't, V: SerializeCql + 't>(
         .finish()
         .map_err(|_| mk_ser_err_named(rust_name, typ, BuiltinSerializationErrorKind::SizeOverflow))
 }
+
+fn serialize_udt<'b>(
+    typ: &ColumnType,
+    keyspace: &str,
+    type_name: &str,
+    values: &[(String, Option<CassCqlValue>)],
+    writer: CellWriter<'b>,
+) -> Result<WrittenCellProof<'b>, SerializationError> {
+    let (dst_type_name, dst_keyspace, field_types) = match typ {
+        ColumnType::UserDefinedType {
+            type_name,
+            keyspace,
+            field_types,
+        } => (type_name, keyspace, field_types),
+        _ => {
+            return Err(mk_typck_err::<CassCqlValue>(
+                typ,
+                UdtTypeCheckErrorKind::NotUdt,
+            ))
+        }
+    };
+
+    if keyspace != dst_keyspace || type_name != dst_type_name {
+        return Err(mk_typck_err::<CassCqlValue>(
+            typ,
+            UdtTypeCheckErrorKind::NameMismatch {
+                keyspace: dst_keyspace.clone(),
+                type_name: dst_type_name.clone(),
+            },
+        ));
+    }
+
+    // Allow columns present in the CQL type which are not present in CqlValue,
+    // but not the other way around
+    let mut indexed_fields: HashMap<_, _> = values.iter().map(|(k, v)| (k.as_str(), v)).collect();
+
+    let mut builder = writer.into_value_builder();
+    for (fname, ftyp) in field_types {
+        // Take a value from the original list.
+        // If a field is missing, write null instead.
+        let fvalue = indexed_fields
+            .remove(fname.as_str())
+            .and_then(|x| x.as_ref());
+
+        let writer = builder.make_sub_writer();
+        match fvalue {
+            None => writer.set_null(),
+            Some(v) => <_ as SerializeCql>::serialize(v, ftyp, writer).map_err(|err| {
+                mk_ser_err::<CassCqlValue>(
+                    typ,
+                    UdtSerializationErrorKind::FieldSerializationFailed {
+                        field_name: fname.clone(),
+                        err,
+                    },
+                )
+            })?,
+        };
+    }
+
+    // If there are some leftover fields, it's an error.
+    if !indexed_fields.is_empty() {
+        // In order to have deterministic errors, return an error about
+        // the lexicographically smallest field.
+        let fname = indexed_fields.keys().min().unwrap();
+        return Err(mk_typck_err::<CassCqlValue>(
+            typ,
+            UdtTypeCheckErrorKind::NoSuchFieldInUdt {
+                field_name: fname.to_string(),
+            },
+        ));
+    }
+
+    builder
+        .finish()
+        .map_err(|_| mk_ser_err::<CassCqlValue>(typ, BuiltinSerializationErrorKind::SizeOverflow))
+}