Add skip attribute to serialization proc macros

scylla-cql/src/macros.rs

@@ -117,6 +117,10 @@ pub use scylla_macros::ValueList;
 ///
 /// Serializes the field to the UDT struct field with given name instead of
 /// its Rust name.
+///
+/// `#[scylla(skip)]`
+///
+/// Don't use the field during serialization.
 pub use scylla_macros::SerializeCql;
 
 /// Derive macro for the [`SerializeRow`](crate::types::serialize::row::SerializeRow) trait
@@ -211,6 +215,10 @@ pub use scylla_macros::SerializeCql;
 ///
 /// Serializes the field to the column / bind marker with given name instead of
 /// its Rust name.
+///
+/// `#[scylla(skip)]`
+///
+/// Don't use the field during serialization.
 pub use scylla_macros::SerializeRow;
 
 // Reexports for derive(IntoUserType)

scylla-cql/src/types/serialize/row.rs

@@ -1519,4 +1519,44 @@ mod tests {
 
         assert_eq!(reference, row);
     }
+
+    #[derive(SerializeRow, Debug)]
+    #[scylla(crate = crate)]
+    struct TestRowWithSkippedFields {
+        a: String,
+        b: i32,
+        #[scylla(skip)]
+        #[allow(dead_code)]
+        skipped: Vec<String>,
+        c: Vec<i64>,
+    }
+
+    #[test]
+    fn test_row_serialization_with_skipped_field() {
+        let spec = [
+            col("a", ColumnType::Text),
+            col("b", ColumnType::Int),
+            col("c", ColumnType::List(Box::new(ColumnType::BigInt))),
+        ];
+
+        let reference = do_serialize(
+            TestRowWithColumnSorting {
+                a: "Ala ma kota".to_owned(),
+                b: 42,
+                c: vec![1, 2, 3],
+            },
+            &spec,
+        );
+        let row = do_serialize(
+            TestRowWithSkippedFields {
+                a: "Ala ma kota".to_owned(),
+                b: 42,
+                skipped: vec!["abcd".to_owned(), "efgh".to_owned()],
+                c: vec![1, 2, 3],
+            },
+            &spec,
+        );
+
+        assert_eq!(reference, row);
+    }
 }

scylla-cql/src/types/serialize/value.rs

@@ -2692,4 +2692,51 @@ mod tests {
             BuiltinTypeCheckErrorKind::UdtError(UdtTypeCheckErrorKind::NoSuchFieldInUdt { .. })
         ));
     }
+
+    #[derive(SerializeCql, Debug)]
+    #[scylla(crate = crate, flavor = "enforce_order", skip_name_checks)]
+    struct TestUdtWithSkippedFields {
+        a: String,
+        b: i32,
+        #[scylla(skip)]
+        #[allow(dead_code)]
+        skipped: Vec<String>,
+        c: Vec<i64>,
+    }
+
+    #[test]
+    fn test_row_serialization_with_skipped_field() {
+        let typ = ColumnType::UserDefinedType {
+            type_name: "typ".to_string(),
+            keyspace: "ks".to_string(),
+            field_types: vec![
+                ("a".to_string(), ColumnType::Text),
+                ("b".to_string(), ColumnType::Int),
+                (
+                    "c".to_string(),
+                    ColumnType::List(Box::new(ColumnType::BigInt)),
+                ),
+            ],
+        };
+
+        let reference = do_serialize(
+            TestUdtWithFieldSorting {
+                a: "Ala ma kota".to_owned(),
+                b: 42,
+                c: vec![1, 2, 3],
+            },
+            &typ,
+        );
+        let row = do_serialize(
+            TestUdtWithSkippedFields {
+                a: "Ala ma kota".to_owned(),
+                b: 42,
+                skipped: vec!["abcd".to_owned(), "efgh".to_owned()],
+                c: vec![1, 2, 3],
+            },
+            &typ,
+        );
+
+        assert_eq!(reference, row);
+    }
 }

scylla-macros/src/serialize/cql.rs

@@ -51,6 +51,9 @@ impl Field {
 #[darling(attributes(scylla))]
 struct FieldAttributes {
     rename: Option<String>,
+
+    #[darling(default)]
+    skip: bool,
 }
 
 struct Context {
@@ -78,6 +81,9 @@ pub fn derive_serialize_cql(tokens_input: TokenStream) -> Result<syn::ItemImpl,
                 attrs,
             })
         })
+        // Filter the fields now instead of at the places that use them later
+        // as it's less error prone - we just filter in one place instead of N places.
+        .filter(|f| f.as_ref().map(|f| !f.attrs.skip).unwrap_or(true))
         .collect::<Result<_, _>>()?;
     let ctx = Context { attributes, fields };
     ctx.validate(&input.ident)?;

scylla-macros/src/serialize/row.rs

@@ -48,6 +48,9 @@ impl Field {
 #[darling(attributes(scylla))]
 struct FieldAttributes {
     rename: Option<String>,
+
+    #[darling(default)]
+    skip: bool,
 }
 
 struct Context {
@@ -75,6 +78,9 @@ pub fn derive_serialize_row(tokens_input: TokenStream) -> Result<syn::ItemImpl,
                 attrs,
             })
         })
+        // Filter the fields now instead of at the places that use them later
+        // as it's less error prone - we just filter in one place instead of N places.
+        .filter(|f| f.as_ref().map(|f| !f.attrs.skip).unwrap_or(true))
         .collect::<Result<_, _>>()?;
     let ctx = Context { attributes, fields };
     ctx.validate(&input.ident)?;