ser: map

Author: muzarski

scylla-rust-wrapper/src/value.rs

@@ -5,8 +5,9 @@ use scylla::{
     serialize::{
         value::{
             BuiltinSerializationError, BuiltinSerializationErrorKind, BuiltinTypeCheckError,
-            BuiltinTypeCheckErrorKind, SerializeCql, SetOrListSerializationErrorKind,
-            SetOrListTypeCheckErrorKind, TupleSerializationErrorKind, TupleTypeCheckErrorKind,
+            BuiltinTypeCheckErrorKind, MapSerializationErrorKind, MapTypeCheckErrorKind,
+            SerializeCql, SetOrListSerializationErrorKind, SetOrListTypeCheckErrorKind,
+            TupleSerializationErrorKind, TupleTypeCheckErrorKind,
         },
         writers::WrittenCellProof,
         CellWriter, SerializationError,
@@ -99,7 +100,9 @@ impl SerializeCql for CassCqlValue {
                 serialize_tuple_like(typ, fields.iter(), t.iter(), writer)
             }
             CassCqlValue::List(l) => serialize_sequence(l.len(), l.iter(), typ, writer),
-            CassCqlValue::Map(_) => todo!(),
+            CassCqlValue::Map(m) => {
+                serialize_mapping(m.len(), m.iter().map(|p| (&p.0, &p.1)), typ, writer)
+            }
             CassCqlValue::Set(s) => serialize_sequence(s.len(), s.iter(), typ, writer),
             CassCqlValue::UserDefinedType {
                 keyspace,
@@ -306,3 +309,51 @@ fn serialize_sequence<'t, 'b, T: SerializeCql + 't>(
         .finish()
         .map_err(|_| mk_ser_err_named(rust_name, typ, BuiltinSerializationErrorKind::SizeOverflow))
 }
+
+fn serialize_mapping<'t, 'b, K: SerializeCql + 't, V: SerializeCql + 't>(
+    len: usize,
+    iter: impl Iterator<Item = (&'t K, &'t V)>,
+    typ: &ColumnType,
+    writer: CellWriter<'b>,
+) -> Result<WrittenCellProof<'b>, SerializationError> {
+    let rust_name = std::any::type_name::<CassCqlValue>();
+
+    let (ktyp, vtyp) = match typ {
+        ColumnType::Map(k, v) => (k, v),
+        _ => {
+            return Err(mk_typck_err_named(
+                rust_name,
+                typ,
+                MapTypeCheckErrorKind::NotMap,
+            ));
+        }
+    };
+
+    let mut builder = writer.into_value_builder();
+
+    let element_count: i32 = len.try_into().map_err(|_| {
+        mk_ser_err_named(rust_name, typ, MapSerializationErrorKind::TooManyElements)
+    })?;
+    builder.append_bytes(&element_count.to_be_bytes());
+
+    for (k, v) in iter {
+        K::serialize(k, ktyp, builder.make_sub_writer()).map_err(|err| {
+            mk_ser_err_named(
+                rust_name,
+                typ,
+                MapSerializationErrorKind::KeySerializationFailed(err),
+            )
+        })?;
+        V::serialize(v, vtyp, builder.make_sub_writer()).map_err(|err| {
+            mk_ser_err_named(
+                rust_name,
+                typ,
+                MapSerializationErrorKind::ValueSerializationFailed(err),
+            )
+        })?;
+    }
+
+    builder
+        .finish()
+        .map_err(|_| mk_ser_err_named(rust_name, typ, BuiltinSerializationErrorKind::SizeOverflow))
+}