diff --git a/.github/workflows/scylla.yml b/.github/workflows/scylla.yml
index bc65ed1..0d43eaf 100644
--- a/.github/workflows/scylla.yml
+++ b/.github/workflows/scylla.yml
@@ -24,10 +24,10 @@ jobs:
           - ${{ github.workspace }}:/workspace
     steps:
       - uses: actions/checkout@v2
-      - name: Install stable 1.66
+      - name: Install stable 1.73
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.72.0
+          toolchain: 1.73.0
           default: true
           components: rustfmt, clippy
       - name: Load .env file
diff --git a/.gitignore b/.gitignore
index e4984d4..df8233a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 /target/
-.idea
\ No newline at end of file
+.idea
+.DS_Store
\ No newline at end of file
diff --git a/.run/Test all.run.xml b/.run/Test all.run.xml
index bdc8e95..487315f 100644
--- a/.run/Test all.run.xml	
+++ b/.run/Test all.run.xml	
@@ -9,7 +9,9 @@
     <option name="withSudo" value="false" />
     <option name="buildTarget" value="REMOTE" />
     <option name="backtrace" value="SHORT" />
-    <envs />
+    <envs>
+      <env name="TRYBUILD" value="overwrite" />
+    </envs>
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />
     <method v="2">
diff --git a/Cargo.lock b/Cargo.lock
index cbc6948..37836ef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -125,7 +125,7 @@ checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
 
 [[package]]
 name = "catalytic"
-version = "0.1.16"
+version = "0.1.18"
 dependencies = [
  "dotenv",
  "futures-util",
@@ -140,7 +140,7 @@ dependencies = [
 
 [[package]]
 name = "catalytic_macro"
-version = "0.1.16"
+version = "0.1.18"
 dependencies = [
  "catalytic",
  "catalytic_query_parser",
@@ -155,7 +155,7 @@ dependencies = [
 
 [[package]]
 name = "catalytic_query_parser"
-version = "0.1.16"
+version = "0.1.18"
 dependencies = [
  "catalytic",
  "catalytic_macro",
@@ -171,7 +171,7 @@ dependencies = [
 
 [[package]]
 name = "catalytic_table_to_struct"
-version = "0.1.16"
+version = "0.1.18"
 dependencies = [
  "catalytic",
  "heck 0.4.1",
@@ -193,14 +193,14 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.26"
+version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec837a71355b28f6556dbd569b37b3f363091c0bd4b2e735674521b4c5fd9bc5"
+checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "num-traits",
- "winapi",
+ "windows-targets",
 ]
 
 [[package]]
@@ -242,7 +242,7 @@ checksum = "88bffebc5d80432c9b140ee17875ff173a8ab62faad5b257da912bd2f6c1c0a1"
 
 [[package]]
 name = "example_project"
-version = "0.1.16"
+version = "0.1.18"
 dependencies = [
  "catalytic",
  "catalytic_macro",
@@ -793,9 +793,9 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "scylla"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b9aa2b618718b5d4873926cecb99fe181a3b8c52b4983e2b20d6d833bfa9c1b"
+checksum = "344a57b2b4d7e86372f86967d709f2232f72e45fc8eceb341ff39b4d482ab485"
 dependencies = [
  "arc-swap",
  "async-trait",
@@ -827,9 +827,9 @@ dependencies = [
 
 [[package]]
 name = "scylla-cql"
-version = "0.0.8"
+version = "0.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "048bdf0be96308ec0f5aeed2847bb2270f53355425b3afd67e64efc99d70b3e3"
+checksum = "c9642864295085ef2fe62493eec405a109fbaae9f3a9b80ea087556af4a97df2"
 dependencies = [
  "async-trait",
  "bigdecimal",
@@ -848,13 +848,13 @@ dependencies = [
 
 [[package]]
 name = "scylla-macros"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32d777dadbf7163d1524ea4f5a095146298d263a686febb96d022cf46d06df32"
+checksum = "5757ded3dfb10967ca7d1ff1084d072d565b5e10b2b21c286d5335c245425a7e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.31",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index b314b8e..7aede72 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.1.17"
+version = "0.1.18"
 authors = ["Jasper Visser <jasperav@hotmail.com>"]
 repository = "https://github.com/Jasperav/catalytic"
 readme = "../README.md"
@@ -19,7 +19,7 @@ categories = ["database"]
 license = "MIT"
 
 [workspace.dependencies]
-scylla = "0.9.0" # This crate is specifically build for this version
+scylla = "0.10.0" # This crate is specifically build for this version
 once_cell = "1.18"
 heck = "0.4"
 tokio = { version = "1", features = ["time", "rt-multi-thread", "io-util"] }
diff --git a/catalytic_query_parser/src/extract_query_metadata.rs b/catalytic_query_parser/src/extract_query_metadata.rs
index 0863d3c..982dfd3 100644
--- a/catalytic_query_parser/src/extract_query_metadata.rs
+++ b/catalytic_query_parser/src/extract_query_metadata.rs
@@ -44,16 +44,11 @@ pub fn extract_query_meta_data(query: impl AsRef<str>) -> QueryMetadata {
             column_type: ColumnType::Int,
             value: ParameterizedValue::Limit,
         });
-    } else {
-        match ttl {
-            Some(ttl) if ttl == Ttl::Parameterized => {
-                parameterized_columns_types.push(ParameterizedColumnType {
-                    column_type: ColumnType::Int,
-                    value: ParameterizedValue::UsingTtl,
-                });
-            }
-            _ => {} // Do nothing
-        }
+    } else if let Some(Ttl::Parameterized) = ttl {
+        parameterized_columns_types.push(ParameterizedColumnType {
+            column_type: ColumnType::Int,
+            value: ParameterizedValue::UsingTtl,
+        });
     }
 
     // ColumnInTable can be reused in ranges, so filter duplicates
@@ -123,7 +118,7 @@ pub fn replace_select_wildcard(query: &str, columns: &[ColumnInTable]) -> String
 pub fn test_query(query: impl AsRef<str>) -> QueryMetadata {
     let query = query.as_ref();
     let qmd = extract_query_meta_data(query);
-    let mut values = SerializedValues::with_capacity(qmd.parameterized_columns_types.len());
+    let mut values = SerializedValues::new();
 
     for parameterized_column_type in &qmd.parameterized_columns_types {
         add_random_value(&mut values, parameterized_column_type);
diff --git a/catalytic_query_parser/src/lib.rs b/catalytic_query_parser/src/lib.rs
index 4d828ca..ef0423c 100644
--- a/catalytic_query_parser/src/lib.rs
+++ b/catalytic_query_parser/src/lib.rs
@@ -183,7 +183,6 @@ impl Parse for Query {
             .iter()
             .filter(|r| r.parameterized)
             .collect::<Vec<_>>();
-        let ident_count = idents.len();
         let types_comparison = idents
             .iter()
             .enumerate()
@@ -205,7 +204,13 @@ impl Parse for Query {
             .collect::<Vec<syn::Type>>();
 
         let serialized_values = quote! {{
-            let mut serialized_values = catalytic::scylla::frame::value::SerializedValues::with_capacity(#ident_count);
+            let mut size = 0;
+
+            #(
+              size += std::mem::size_of_val(#idents);
+            )*
+
+            let mut serialized_values = catalytic::scylla::frame::value::SerializedValues::with_capacity(size);
 
             #(
                 // Check if the type is correct
diff --git a/catalytic_table_to_struct/example/src/generated/another_test_table.rs b/catalytic_table_to_struct/example/src/generated/another_test_table.rs
index c73d0dd..c7f5c7a 100644
--- a/catalytic_table_to_struct/example/src/generated/another_test_table.rs
+++ b/catalytic_table_to_struct/example/src/generated/another_test_table.rs
@@ -171,7 +171,12 @@ pub async fn truncate(session: &CachingSession) -> ScyllaQueryResult {
 impl<'a> AnotherTestTableRef<'a> {
     #[doc = r" Returns a struct that can perform an insert operation"]
     pub fn insert_qv(&self) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(4usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.a);
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        size += std::mem::size_of_val(self.d);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.a)?;
         serialized.add_value(&self.b)?;
         serialized.add_value(&self.c)?;
@@ -188,7 +193,13 @@ impl<'a> AnotherTestTableRef<'a> {
     }
     #[doc = r" Returns a struct that can perform an insert operation with a TTL"]
     pub fn insert_ttl_qv(&self, ttl: TtlType) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(5usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.a);
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        size += std::mem::size_of_val(self.d);
+        size += std::mem::size_of_val(&ttl);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.a)?;
         serialized.add_value(&self.b)?;
         serialized.add_value(&self.c)?;
@@ -281,7 +292,11 @@ impl From<PrimaryKeyRef<'_>> for PrimaryKey {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a unique row selection"]
     pub fn select_unique_qv(&self) -> Result<SelectUnique<AnotherTestTable>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.a);
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.a)?;
         serialized_values.add_value(&self.b)?;
         serialized_values.add_value(&self.c)?;
@@ -308,7 +323,11 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_expect_qv(
         &self,
     ) -> Result<SelectUniqueExpect<AnotherTestTable>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.a);
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.a)?;
         serialized_values.add_value(&self.b)?;
         serialized_values.add_value(&self.c)?;
@@ -333,7 +352,7 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = "Returns a struct that can perform an update operation for column d"]
     pub fn update_d_qv(&self, val: &i32) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(4usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.a)?;
         serialized_values.add_value(&self.b)?;
@@ -383,7 +402,7 @@ impl PrimaryKeyRef<'_> {
             panic!("Empty update array")
         }
         let mut query = vec![];
-        let mut serialized_values = SerializedValues::with_capacity(val.len() + 3usize);
+        let mut serialized_values = SerializedValues::new();
         for v in val {
             match v {
                 UpdatableColumnRef::D(v) => {
@@ -423,7 +442,11 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a single row deletion"]
     pub fn delete_qv(&self) -> Result<DeleteUnique, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.a);
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.a)?;
         serialized_values.add_value(&self.b)?;
         serialized_values.add_value(&self.c)?;
diff --git a/catalytic_table_to_struct/example/src/generated/child.rs b/catalytic_table_to_struct/example/src/generated/child.rs
index 1818227..5ec8f8a 100644
--- a/catalytic_table_to_struct/example/src/generated/child.rs
+++ b/catalytic_table_to_struct/example/src/generated/child.rs
@@ -171,7 +171,12 @@ pub async fn truncate(session: &CachingSession) -> ScyllaQueryResult {
 impl<'a> ChildRef<'a> {
     #[doc = r" Returns a struct that can perform an insert operation"]
     pub fn insert_qv(&self) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(4usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.birthday);
+        size += std::mem::size_of_val(self.enum_json);
+        size += std::mem::size_of_val(self.json);
+        size += std::mem::size_of_val(self.json_nullable);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.birthday)?;
         serialized.add_value(&self.enum_json)?;
         serialized.add_value(&self.json)?;
@@ -188,7 +193,13 @@ impl<'a> ChildRef<'a> {
     }
     #[doc = r" Returns a struct that can perform an insert operation with a TTL"]
     pub fn insert_ttl_qv(&self, ttl: TtlType) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(5usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.birthday);
+        size += std::mem::size_of_val(self.enum_json);
+        size += std::mem::size_of_val(self.json);
+        size += std::mem::size_of_val(self.json_nullable);
+        size += std::mem::size_of_val(&ttl);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.birthday)?;
         serialized.add_value(&self.enum_json)?;
         serialized.add_value(&self.json)?;
@@ -277,7 +288,9 @@ impl From<PrimaryKeyRef<'_>> for PrimaryKey {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a unique row selection"]
     pub fn select_unique_qv(&self) -> Result<SelectUnique<Child>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(1usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.birthday);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.birthday)?;
         Ok(SelectUnique::new(Qv {
             query: SELECT_UNIQUE_QUERY,
@@ -302,7 +315,9 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_expect_qv(
         &self,
     ) -> Result<SelectUniqueExpect<Child>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(1usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.birthday);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.birthday)?;
         Ok(SelectUniqueExpect::new(Qv {
             query: SELECT_UNIQUE_QUERY,
@@ -328,7 +343,7 @@ impl PrimaryKeyRef<'_> {
         &self,
         val: &crate::MyJsonEnum,
     ) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.birthday)?;
         Ok(Update::new(Qv {
@@ -354,7 +369,7 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = "Returns a struct that can perform an update operation for column json"]
     pub fn update_json_qv(&self, val: &crate::MyJsonType) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.birthday)?;
         Ok(Update::new(Qv {
@@ -383,7 +398,7 @@ impl PrimaryKeyRef<'_> {
         &self,
         val: &std::option::Option<crate::MyJsonType>,
     ) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.birthday)?;
         Ok(Update::new(Qv {
@@ -437,7 +452,7 @@ impl PrimaryKeyRef<'_> {
             panic!("Empty update array")
         }
         let mut query = vec![];
-        let mut serialized_values = SerializedValues::with_capacity(val.len() + 1usize);
+        let mut serialized_values = SerializedValues::new();
         for v in val {
             match v {
                 UpdatableColumnRef::EnumJson(v) => {
@@ -483,7 +498,9 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a single row deletion"]
     pub fn delete_qv(&self) -> Result<DeleteUnique, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(1usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.birthday);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.birthday)?;
         Ok(DeleteUnique::new(Qv {
             query: DELETE_QUERY,
diff --git a/catalytic_table_to_struct/example/src/generated/field_name_different_combined.rs b/catalytic_table_to_struct/example/src/generated/field_name_different_combined.rs
index 68614f0..7ed0642 100644
--- a/catalytic_table_to_struct/example/src/generated/field_name_different_combined.rs
+++ b/catalytic_table_to_struct/example/src/generated/field_name_different_combined.rs
@@ -166,7 +166,11 @@ pub async fn truncate(session: &CachingSession) -> ScyllaQueryResult {
 impl<'a> FieldNameDifferentCombinedRef<'a> {
     #[doc = r" Returns a struct that can perform an insert operation"]
     pub fn insert_qv(&self) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.row_type);
+        size += std::mem::size_of_val(self.row_pub);
+        size += std::mem::size_of_val(self.row_struct);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.row_type)?;
         serialized.add_value(&self.row_pub)?;
         serialized.add_value(&self.row_struct)?;
@@ -182,7 +186,12 @@ impl<'a> FieldNameDifferentCombinedRef<'a> {
     }
     #[doc = r" Returns a struct that can perform an insert operation with a TTL"]
     pub fn insert_ttl_qv(&self, ttl: TtlType) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(4usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.row_type);
+        size += std::mem::size_of_val(self.row_pub);
+        size += std::mem::size_of_val(self.row_struct);
+        size += std::mem::size_of_val(&ttl);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.row_type)?;
         serialized.add_value(&self.row_pub)?;
         serialized.add_value(&self.row_struct)?;
@@ -271,7 +280,10 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_qv(
         &self,
     ) -> Result<SelectUnique<FieldNameDifferentCombined>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.row_type);
+        size += std::mem::size_of_val(self.row_pub);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.row_type)?;
         serialized_values.add_value(&self.row_pub)?;
         Ok(SelectUnique::new(Qv {
@@ -298,7 +310,10 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_expect_qv(
         &self,
     ) -> Result<SelectUniqueExpect<FieldNameDifferentCombined>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.row_type);
+        size += std::mem::size_of_val(self.row_pub);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.row_type)?;
         serialized_values.add_value(&self.row_pub)?;
         Ok(SelectUniqueExpect::new(Qv {
@@ -325,7 +340,7 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = "Returns a struct that can perform an update operation for column struct"]
     pub fn update_row_struct_qv(&self, val: &str) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.row_type)?;
         serialized_values.add_value(&self.row_pub)?;
@@ -378,7 +393,7 @@ impl PrimaryKeyRef<'_> {
             panic!("Empty update array")
         }
         let mut query = vec![];
-        let mut serialized_values = SerializedValues::with_capacity(val.len() + 2usize);
+        let mut serialized_values = SerializedValues::new();
         for v in val {
             match v {
                 UpdatableColumnRef::RowStruct(v) => {
@@ -417,7 +432,10 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a single row deletion"]
     pub fn delete_qv(&self) -> Result<DeleteUnique, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.row_type);
+        size += std::mem::size_of_val(self.row_pub);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.row_type)?;
         serialized_values.add_value(&self.row_pub)?;
         Ok(DeleteUnique::new(Qv {
diff --git a/catalytic_table_to_struct/example/src/generated/person.rs b/catalytic_table_to_struct/example/src/generated/person.rs
index 792c9e7..c5f81fc 100644
--- a/catalytic_table_to_struct/example/src/generated/person.rs
+++ b/catalytic_table_to_struct/example/src/generated/person.rs
@@ -168,7 +168,12 @@ pub async fn truncate(session: &CachingSession) -> ScyllaQueryResult {
 impl<'a> PersonRef<'a> {
     #[doc = r" Returns a struct that can perform an insert operation"]
     pub fn insert_qv(&self) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(4usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        size += std::mem::size_of_val(self.email);
+        size += std::mem::size_of_val(self.row_type);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.name)?;
         serialized.add_value(&self.age)?;
         serialized.add_value(&self.email)?;
@@ -185,7 +190,13 @@ impl<'a> PersonRef<'a> {
     }
     #[doc = r" Returns a struct that can perform an insert operation with a TTL"]
     pub fn insert_ttl_qv(&self, ttl: TtlType) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(5usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        size += std::mem::size_of_val(self.email);
+        size += std::mem::size_of_val(self.row_type);
+        size += std::mem::size_of_val(&ttl);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.name)?;
         serialized.add_value(&self.age)?;
         serialized.add_value(&self.email)?;
@@ -276,7 +287,10 @@ impl From<PrimaryKeyRef<'_>> for PrimaryKey {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a unique row selection"]
     pub fn select_unique_qv(&self) -> Result<SelectUnique<Person>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
         Ok(SelectUnique::new(Qv {
@@ -302,7 +316,10 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_expect_qv(
         &self,
     ) -> Result<SelectUniqueExpect<Person>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
         Ok(SelectUniqueExpect::new(Qv {
@@ -326,7 +343,7 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = "Returns a struct that can perform an update operation for column email"]
     pub fn update_email_qv(&self, val: &str) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
@@ -349,7 +366,7 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = "Returns a struct that can perform an update operation for column type"]
     pub fn update_row_type_qv(&self, val: &str) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
@@ -399,7 +416,7 @@ impl PrimaryKeyRef<'_> {
             panic!("Empty update array")
         }
         let mut query = vec![];
-        let mut serialized_values = SerializedValues::with_capacity(val.len() + 2usize);
+        let mut serialized_values = SerializedValues::new();
         for v in val {
             match v {
                 UpdatableColumnRef::Email(v) => {
@@ -442,7 +459,10 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a single row deletion"]
     pub fn delete_qv(&self) -> Result<DeleteUnique, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(2usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
         Ok(DeleteUnique::new(Qv {
diff --git a/catalytic_table_to_struct/example/src/generated/person_by_email.rs b/catalytic_table_to_struct/example/src/generated/person_by_email.rs
index e10a393..64da565 100644
--- a/catalytic_table_to_struct/example/src/generated/person_by_email.rs
+++ b/catalytic_table_to_struct/example/src/generated/person_by_email.rs
@@ -225,7 +225,11 @@ impl From<PrimaryKeyRef<'_>> for PrimaryKey {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a unique row selection"]
     pub fn select_unique_qv(&self) -> Result<SelectUnique<PersonByEmail>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.email);
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.email)?;
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
@@ -252,7 +256,11 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_expect_qv(
         &self,
     ) -> Result<SelectUniqueExpect<PersonByEmail>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.email);
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.email)?;
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
@@ -279,7 +287,11 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_base_table_qv(
         &self,
     ) -> Result<SelectUnique<Person>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.email);
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.email)?;
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
@@ -306,7 +318,11 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_expect_base_table_qv(
         &self,
     ) -> Result<SelectUniqueExpect<Person>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(3usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.email);
+        size += std::mem::size_of_val(self.name);
+        size += std::mem::size_of_val(self.age);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.email)?;
         serialized_values.add_value(&self.name)?;
         serialized_values.add_value(&self.age)?;
diff --git a/catalytic_table_to_struct/example/src/generated/test_table.rs b/catalytic_table_to_struct/example/src/generated/test_table.rs
index 2b99fd5..d84c3b6 100644
--- a/catalytic_table_to_struct/example/src/generated/test_table.rs
+++ b/catalytic_table_to_struct/example/src/generated/test_table.rs
@@ -179,7 +179,13 @@ pub async fn truncate(session: &CachingSession) -> ScyllaQueryResult {
 impl<'a> TestTableRef<'a> {
     #[doc = r" Returns a struct that can perform an insert operation"]
     pub fn insert_qv(&self) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(5usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        size += std::mem::size_of_val(self.d);
+        size += std::mem::size_of_val(self.a);
+        size += std::mem::size_of_val(self.e);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.b)?;
         serialized.add_value(&self.c)?;
         serialized.add_value(&self.d)?;
@@ -197,7 +203,14 @@ impl<'a> TestTableRef<'a> {
     }
     #[doc = r" Returns a struct that can perform an insert operation with a TTL"]
     pub fn insert_ttl_qv(&self, ttl: TtlType) -> Result<Insert, SerializeValuesError> {
-        let mut serialized = SerializedValues::with_capacity(6usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        size += std::mem::size_of_val(self.d);
+        size += std::mem::size_of_val(self.a);
+        size += std::mem::size_of_val(self.e);
+        size += std::mem::size_of_val(&ttl);
+        let mut serialized = SerializedValues::with_capacity(size);
         serialized.add_value(&self.b)?;
         serialized.add_value(&self.c)?;
         serialized.add_value(&self.d)?;
@@ -296,7 +309,12 @@ impl From<PrimaryKeyRef<'_>> for PrimaryKey {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a unique row selection"]
     pub fn select_unique_qv(&self) -> Result<SelectUnique<TestTable>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(4usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        size += std::mem::size_of_val(self.d);
+        size += std::mem::size_of_val(self.a);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.b)?;
         serialized_values.add_value(&self.c)?;
         serialized_values.add_value(&self.d)?;
@@ -324,7 +342,12 @@ impl PrimaryKeyRef<'_> {
     pub fn select_unique_expect_qv(
         &self,
     ) -> Result<SelectUniqueExpect<TestTable>, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(4usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        size += std::mem::size_of_val(self.d);
+        size += std::mem::size_of_val(self.a);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.b)?;
         serialized_values.add_value(&self.c)?;
         serialized_values.add_value(&self.d)?;
@@ -350,7 +373,7 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = "Returns a struct that can perform an update operation for column e"]
     pub fn update_e_qv(&self, val: &i32) -> Result<Update, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(5usize);
+        let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
         serialized_values.add_value(&val)?;
         serialized_values.add_value(&self.b)?;
         serialized_values.add_value(&self.c)?;
@@ -401,7 +424,7 @@ impl PrimaryKeyRef<'_> {
             panic!("Empty update array")
         }
         let mut query = vec![];
-        let mut serialized_values = SerializedValues::with_capacity(val.len() + 4usize);
+        let mut serialized_values = SerializedValues::new();
         for v in val {
             match v {
                 UpdatableColumnRef::E(v) => {
@@ -442,7 +465,12 @@ impl PrimaryKeyRef<'_> {
 impl PrimaryKeyRef<'_> {
     #[doc = r" Returns a struct that can perform a single row deletion"]
     pub fn delete_qv(&self) -> Result<DeleteUnique, SerializeValuesError> {
-        let mut serialized_values = SerializedValues::with_capacity(4usize);
+        let mut size = 0;
+        size += std::mem::size_of_val(self.b);
+        size += std::mem::size_of_val(self.c);
+        size += std::mem::size_of_val(self.d);
+        size += std::mem::size_of_val(self.a);
+        let mut serialized_values = SerializedValues::with_capacity(size);
         serialized_values.add_value(&self.b)?;
         serialized_values.add_value(&self.c)?;
         serialized_values.add_value(&self.d)?;
diff --git a/catalytic_table_to_struct/example/src/lib.rs b/catalytic_table_to_struct/example/src/lib.rs
index db206bb..c315f16 100644
--- a/catalytic_table_to_struct/example/src/lib.rs
+++ b/catalytic_table_to_struct/example/src/lib.rs
@@ -251,11 +251,11 @@ mod test {
 
         crate::generated::person::truncate(&session).await.unwrap();
 
-        let name = "doesnt_matter".to_string();
+        let name = "doesnt_matter";
 
         for index in 0..rows_to_generate {
             PersonRef {
-                name: &name,
+                name,
                 age: &index,
                 email: "",
                 row_type: "34",
@@ -429,7 +429,7 @@ mod test {
             assert_eq!(person, row.unwrap());
         }
 
-        let c = 1;
+        let c = &1;
         let transformed_type = query!("select * from test_table where b = 1 and c = ?", c);
 
         // The extracted query should be the columns and not * so it can be used in prepared statements
@@ -449,7 +449,7 @@ mod test {
         assert_eq!(SerializedValues::new(), transformed_type.qv.values);
 
         let _ = query!("select * from test_table where b = 1 and c = 2 and d > 3");
-        let val = 1;
+        let val = &1;
         let _ = query!(
             "select * from test_table where b = 1 and c = 2 and d > ?",
             val
@@ -479,7 +479,7 @@ mod test {
         );
         assert_eq!(SerializedValues::new(), transformed_type.qv.values);
 
-        let a = 1;
+        let a = &1;
         let transformed_type = query!("select * from test_table where b = 1 and c = ?", a);
 
         assert_eq!(
@@ -488,24 +488,21 @@ mod test {
         );
         assert_serialized_values!(transformed_type, a);
 
-        let a = "sadas".to_string();
+        let a = "sadas";
         let transformed_type = query!("select * from another_test_table where a = 1 and b = ?", a);
         assert_serialized_values!(transformed_type, a);
 
-        // 'a' should been borrowed, not owned
-        drop(a);
-
-        let a = vec![1, 2, 3];
+        let a = &vec![1, 2, 3];
         let transformed_type = query!("select * from test_table where b = 1 and c in ?", a);
         assert_serialized_values!(transformed_type, a);
 
-        let a = vec![1, 2];
+        let a = &vec![1, 2];
         let transformed_type = query!("select * from test_table where b = 1 and c in ? limit 1", a);
         assert_serialized_values!(transformed_type, a);
 
-        let c = vec![1, 2];
-        let b = 1;
-        let limit = 5;
+        let c = &vec![1, 2];
+        let b = &1;
+        let limit = &5;
         let transformed_type = query!(
             "select * from test_table where b = ? and c in ? limit ?",
             b,
diff --git a/catalytic_table_to_struct/example/src/non_compiling_code/failing_wrong_type_vec.rs b/catalytic_table_to_struct/example/src/non_compiling_code/failing_wrong_type_vec.rs
index 982651a..5e5cb90 100644
--- a/catalytic_table_to_struct/example/src/non_compiling_code/failing_wrong_type_vec.rs
+++ b/catalytic_table_to_struct/example/src/non_compiling_code/failing_wrong_type_vec.rs
@@ -6,7 +6,7 @@ mod generated {
 }
 
 fn main() -> Result<(), scylla::frame::value::SerializeValuesError> {
-    let a = 1;
+    let a = &1;
 
     query!("select * from test_table where b = 1 and c in ?", a);
 
diff --git a/catalytic_table_to_struct/src/entity_writer/write_primary_key.rs b/catalytic_table_to_struct/src/entity_writer/write_primary_key.rs
index d278603..e79f90e 100644
--- a/catalytic_table_to_struct/src/entity_writer/write_primary_key.rs
+++ b/catalytic_table_to_struct/src/entity_writer/write_primary_key.rs
@@ -30,24 +30,33 @@ pub(crate) fn write<T: Transformer>(
     let mut primary_key_ref_fields = vec![];
     let mut primary_key_to_ref = vec![];
     let mut primary_key_from_ref = vec![];
-    let primary_key_len = entity_writer.struct_field_metadata.primary_key_fields.len();
-    let add_to_serialized_values = entity_writer
+    let ident_field_names = entity_writer
         .struct_field_metadata
         .primary_key_fields
         .iter()
-        .map(|f| {
-            let ident = &f.field_name;
-
+        .map(|f| &f.field_name)
+        .collect::<Vec<_>>();
+    let add_to_serialized_values = ident_field_names
+        .iter()
+        .map(|i| {
             quote! {
-                serialized_values.add_value(&self.#ident)?;
+                serialized_values.add_value(&self.#i)?;
             }
         })
         .collect::<Vec<_>>();
 
     let serialize = quote! {
-        let mut serialized_values = SerializedValues::with_capacity(#primary_key_len);
+        let mut size = 0;
 
-        #(#add_to_serialized_values)*
+        #(
+          size += std::mem::size_of_val(self.#ident_field_names);
+        )*
+
+        let mut serialized_values = SerializedValues::with_capacity(size);
+
+        #(
+            serialized_values.add_value(&self.#ident_field_names)?;
+        )*
     };
 
     for field in &entity_writer.struct_field_metadata.primary_key_fields {
@@ -189,7 +198,6 @@ pub(crate) fn write<T: Transformer>(
                         "update {} set {} = ? {}",
                         table_name, field.column_name, where_clause
                     );
-                    let single_update_len = primary_key_len + 1;
                     let method_name_qv = qv(&method_name);
                     let message_return = format!(
                         "Returns a struct that can perform an update operation for column {}",
@@ -210,7 +218,7 @@ pub(crate) fn write<T: Transformer>(
                     impl #primary_key_struct_ref<'_> {
                         #[doc = #message_return]
                         pub fn #method_name_qv(&self, val: &#ty) -> Result<Update, SerializeValuesError> {
-                            let mut serialized_values = SerializedValues::with_capacity(#single_update_len);
+                            let mut serialized_values = SerializedValues::with_capacity(std::mem::size_of_val(val));
 
                             serialized_values.add_value(&val)?;
 
@@ -291,7 +299,10 @@ pub(crate) fn write<T: Transformer>(
                         }
 
                         let mut query = vec![];
-                        let mut serialized_values = SerializedValues::with_capacity(val.len() + #primary_key_len);
+
+                        // Hard to calculate the size in advance, I guess it's not performant to loop over the values
+                        // and calculate the sizes then
+                        let mut serialized_values = SerializedValues::new();
 
                         for v in val {
                             match v {
diff --git a/catalytic_table_to_struct/src/entity_writer/write_struct.rs b/catalytic_table_to_struct/src/entity_writer/write_struct.rs
index bf8e2da..1ef85de 100644
--- a/catalytic_table_to_struct/src/entity_writer/write_struct.rs
+++ b/catalytic_table_to_struct/src/entity_writer/write_struct.rs
@@ -219,8 +219,6 @@ pub(crate) fn write<T: Transformer>(
             let insert_ttl_constant = insert_ttl_constant();
             let truncate_fn_name = truncate_fn_name();
             let truncate_constant = truncate_constant();
-            let field_count = entity_writer.struct_field_metadata.fields.len();
-            let insert_with_ttl_values_len = field_count + 1;
             let idents = entity_writer.ident_fields();
             let truncate = entity_writer.truncate();
             let insert = entity_writer.insert();
@@ -248,7 +246,13 @@ pub(crate) fn write<T: Transformer>(
                 impl <'a> #struct_name_ref_ident<'a> {
                     /// Returns a struct that can perform an insert operation
                     pub fn #insert_qv(&self) -> Result<#insert, SerializeValuesError> {
-                        let mut serialized = SerializedValues::with_capacity(#field_count);
+                        let mut size = 0;
+
+                        #(
+                          size += std::mem::size_of_val(self.#idents);
+                        )*;
+
+                        let mut serialized = SerializedValues::with_capacity(size);
 
                         #(serialized.add_value(&self.#idents)?);*;
 
@@ -268,7 +272,15 @@ pub(crate) fn write<T: Transformer>(
 
                     /// Returns a struct that can perform an insert operation with a TTL
                     pub fn #insert_ttl_qv(&self, ttl: TtlType) -> Result<#insert, SerializeValuesError> {
-                        let mut serialized = SerializedValues::with_capacity(#insert_with_ttl_values_len);
+                        let mut size = 0;
+
+                        #(
+                            size += std::mem::size_of_val(self.#idents);
+                        )*
+
+                        size += std::mem::size_of_val(&ttl);
+
+                        let mut serialized = SerializedValues::with_capacity(size);
 
                         #(serialized.add_value(&self.#idents)?);*;