UDT ComplexType

Expand ComplexType to include UDTs.

Author: PiotrJunior

lib/types/cql-utils.js

@@ -120,19 +120,26 @@ function encodeTuple(value, type) {
 /**
  * Encodes UDT into QueryParameterWrapper
  * @param {Object} value
- * @param {rust.ComplexType} complexType
+ * @param {rust.ComplexType} type
  * @returns {Array}
  */
-function encodeUdt(value, complexType) {
-    let names = [];
-    let values = [];
-    while (complexType) {
-        let name = complexType.getFieldName();
-        names.push(name);
-        values.push(getWrapped(complexType.getFirstSupportType(), value[name]));
-        complexType = complexType.getSecondSupportType();
+function encodeUdt(value, type) {
+    let names = type.getFieldNames();
+    let types = type.getInnerTypes();
+    let encodedElements = [];
+
+    if (names.length != types.length) {
+        throw new TypeError(
+            `Expected ${types.length} names in UDT, obtained ${names.length} names`,
+        );
+    }
+
+    for (let i = 0; i < names.length; i++) {
+        if (value.hasOwnProperty(names[i])) {
+            encodedElements.push(getWrapped(types[i], value[names[i]]));
+        }
     }
-    return [names, values];
+    return [names, encodedElements];
 }
 
 /**

src/result.rs

@@ -505,7 +505,14 @@ pub(crate) fn map_column_type_to_complex_type(typ: &ColumnType) -> ComplexType {
             ),
             other => unimplemented!("Missing implementation for CQL Collection type {:?}", other),
         },
-        ColumnType::UserDefinedType { .. } => ComplexType::simple_type(CqlType::UserDefinedType),
+        ColumnType::UserDefinedType {
+            frozen: _,
+            definition,
+        } => ComplexType::from_udt(
+            definition.field_types.as_slice(),
+            definition.name.to_string(),
+            definition.keyspace.to_string(),
+        ),
         ColumnType::Tuple(t) => ComplexType::from_tuple(t.as_slice()),
         ColumnType::Vector {
             typ: _,

src/types/type_wrappers.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::result::map_column_type_to_complex_type;
 use scylla::frame::response::result::ColumnType;
 
@@ -42,6 +44,9 @@ pub struct ComplexType {
     pub(crate) support_type_1: Option<Box<ComplexType>>,
     pub(crate) support_type_2: Option<Box<ComplexType>>,
     pub(crate) inner_types: Vec<ComplexType>, // Used by Tuple and UDT
+    pub(crate) field_names: Vec<String>,
+    pub(crate) udt_keyspace: Option<String>,
+    pub(crate) udt_name: Option<String>,
 }
 
 #[napi]
@@ -61,6 +66,22 @@ impl ComplexType {
         // Batch query to NAPI minimizes number of calls
         self.inner_types.clone()
     }
+
+    #[napi]
+    pub fn get_field_names(&self) -> Vec<String> {
+        // Batch query to NAPI minimizes number of calls
+        self.field_names.clone()
+    }
+
+    #[napi]
+    pub fn get_udt_keyspace(&self) -> Option<String> {
+        self.udt_keyspace.clone()
+    }
+
+    #[napi]
+    pub fn get_udt_name(&self) -> Option<String> {
+        self.udt_name.clone()
+    }
 }
 
 impl ComplexType {
@@ -85,6 +106,9 @@ impl ComplexType {
             support_type_1: support1.map(Box::new),
             support_type_2: support2.map(Box::new),
             inner_types: vec![],
+            field_names: vec![],
+            udt_keyspace: None,
+            udt_name: None,
         }
     }
 
@@ -97,6 +121,28 @@ impl ComplexType {
                 .iter()
                 .map(|column| map_column_type_to_complex_type(column))
                 .collect(),
+            field_names: vec![],
+            udt_keyspace: None,
+            udt_name: None,
+        }
+    }
+
+    pub(crate) fn from_udt(
+        items: &[(Cow<str>, ColumnType)],
+        name: String,
+        keyspace: String,
+    ) -> Self {
+        ComplexType {
+            base_type: CqlType::UserDefinedType,
+            support_type_1: None,
+            support_type_2: None,
+            inner_types: items
+                .iter()
+                .map(|(_, column)| map_column_type_to_complex_type(column))
+                .collect(),
+            field_names: items.iter().map(|(name, _)| name.to_string()).collect(),
+            udt_keyspace: Some(keyspace),
+            udt_name: Some(name),
         }
     }
 }