refactor: turn COLUMN_NAME/COLUMN_COUNT consts into functions

timvermeulen · timvermeulen · commit e7e2322d15e4 · 2025-08-25T18:29:36.000+02:00
diff --git a/derive/src/lib.rs b/derive/src/lib.rs
@@ -26,11 +26,11 @@ fn column_names(data: &DataStruct, cx: &Ctxt, container: &Container) -> Result<T
                 });
 
             quote! {
-                &[#( #column_names_iter,)*]
+                [#( #column_names_iter,)*]
             }
         }
         Fields::Unnamed(_) => {
-            quote! { &[] }
+            quote! { [] }
         }
         Fields::Unit => unreachable!("checked by the caller"),
     })
@@ -94,8 +94,8 @@ fn row_impl(input: DeriveInput) -> Result<TokenStream> {
         #[automatically_derived]
         impl #impl_generics clickhouse::Row for #name #ty_generics #where_clause {
             const NAME: &'static str = stringify!(#name);
-            const COLUMN_NAMES: &'static [&'static str] = #column_names;
-            const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+            fn column_names() -> impl IntoIterator<Item = &'static str> { #column_names }
+            fn column_count() -> usize { <Self as clickhouse::Row>::column_names().into_iter().count() }
             const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
 
             type Value<'__v> = #value;
diff --git a/derive/src/tests/snapshots/generic_borrowed_row-2.snap b/derive/src/tests/snapshots/generic_borrowed_row-2.snap
@@ -11,8 +11,12 @@ struct Sample<'a, A, B> {
 #[automatically_derived]
 impl<'a, A, B> clickhouse::Row for Sample<'a, A, B> {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Sample<'__v, A, B>;
 }
diff --git a/derive/src/tests/snapshots/generic_borrowed_row-3.snap b/derive/src/tests/snapshots/generic_borrowed_row-3.snap
@@ -17,8 +17,12 @@ where
     T: Clone,
 {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Sample<'__v, T>;
 }
diff --git a/derive/src/tests/snapshots/generic_borrowed_row.snap b/derive/src/tests/snapshots/generic_borrowed_row.snap
@@ -11,8 +11,12 @@ struct Sample<'a, T> {
 #[automatically_derived]
 impl<'a, T> clickhouse::Row for Sample<'a, T> {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Sample<'__v, T>;
 }
diff --git a/derive/src/tests/snapshots/generic_owned_row-2.snap b/derive/src/tests/snapshots/generic_owned_row-2.snap
@@ -11,8 +11,12 @@ struct Sample<A, B> {
 #[automatically_derived]
 impl<A, B> clickhouse::Row for Sample<A, B> {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Self;
 }
diff --git a/derive/src/tests/snapshots/generic_owned_row-3.snap b/derive/src/tests/snapshots/generic_owned_row-3.snap
@@ -17,8 +17,12 @@ where
     T: Clone,
 {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Self;
 }
diff --git a/derive/src/tests/snapshots/generic_owned_row.snap b/derive/src/tests/snapshots/generic_owned_row.snap
@@ -11,8 +11,12 @@ struct Sample<T> {
 #[automatically_derived]
 impl<T> clickhouse::Row for Sample<T> {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Self;
 }
diff --git a/derive/src/tests/snapshots/serde_rename.snap b/derive/src/tests/snapshots/serde_rename.snap
@@ -14,8 +14,12 @@ struct Sample {
 #[automatically_derived]
 impl clickhouse::Row for Sample {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "items.a", "items.b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "items.a", "items.b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Self;
 }
diff --git a/derive/src/tests/snapshots/serde_skip_deserializing.snap b/derive/src/tests/snapshots/serde_skip_deserializing.snap
@@ -12,8 +12,12 @@ struct Sample {
 #[automatically_derived]
 impl clickhouse::Row for Sample {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Self;
 }
diff --git a/derive/src/tests/snapshots/serde_skip_serializing.snap b/derive/src/tests/snapshots/serde_skip_serializing.snap
@@ -12,8 +12,12 @@ struct Sample {
 #[automatically_derived]
 impl clickhouse::Row for Sample {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Self;
 }
diff --git a/derive/src/tests/snapshots/simple_borrowed_row.snap b/derive/src/tests/snapshots/simple_borrowed_row.snap
@@ -11,8 +11,12 @@ struct Sample<'a> {
 #[automatically_derived]
 impl<'a> clickhouse::Row for Sample<'a> {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Sample<'__v>;
 }
diff --git a/derive/src/tests/snapshots/simple_owned_row.snap b/derive/src/tests/snapshots/simple_owned_row.snap
@@ -11,8 +11,12 @@ struct Sample {
 #[automatically_derived]
 impl clickhouse::Row for Sample {
     const NAME: &'static str = stringify!(Sample);
-    const COLUMN_NAMES: &'static [&'static str] = &["a", "b"];
-    const COLUMN_COUNT: usize = <Self as clickhouse::Row>::COLUMN_NAMES.len();
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        ["a", "b"]
+    }
+    fn column_count() -> usize {
+        <Self as clickhouse::Row>::column_names().into_iter().count()
+    }
     const KIND: clickhouse::_priv::RowKind = clickhouse::_priv::RowKind::Struct;
     type Value<'__v> = Self;
 }
diff --git a/src/row.rs b/src/row.rs
@@ -29,9 +29,9 @@ pub trait Row {
     const NAME: &'static str;
     // TODO: different list for SELECT/INSERT (de/ser)
     #[doc(hidden)]
-    const COLUMN_NAMES: &'static [&'static str];
+    fn column_names() -> impl IntoIterator<Item = &'static str>;
     #[doc(hidden)]
-    const COLUMN_COUNT: usize;
+    fn column_count() -> usize;
     #[doc(hidden)]
     const KIND: RowKind;
     #[doc(hidden)]
@@ -220,8 +220,8 @@ macro_rules! impl_row_for_tuple {
     ($i:ident $($other:ident)+) => {
         impl<$i: Row, $($other: Primitive),+> Row for ($i, $($other),+) {
             const NAME: &'static str = $i::NAME;
-            const COLUMN_NAMES: &'static [&'static str] = $i::COLUMN_NAMES;
-            const COLUMN_COUNT: usize = $i::COLUMN_COUNT + count_tokens!($($other)*);
+            fn column_names() -> impl IntoIterator<Item = &'static str> { $i::column_names() }
+            fn column_count() -> usize { $i::column_count() + count_tokens!($($other)*) }
             const KIND: RowKind = RowKind::Tuple;
 
             type Value<'a> = Self;
@@ -237,8 +237,12 @@ impl Primitive for () {}
 
 impl<P: Primitive> Row for P {
     const NAME: &'static str = stringify!(P);
-    const COLUMN_NAMES: &'static [&'static str] = &[];
-    const COLUMN_COUNT: usize = 1;
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        []
+    }
+    fn column_count() -> usize {
+        1
+    }
     const KIND: RowKind = RowKind::Primitive;
 
     type Value<'a> = Self;
@@ -248,29 +252,34 @@ impl_row_for_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8);
 
 impl<T> Row for Vec<T> {
     const NAME: &'static str = "Vec";
-    const COLUMN_NAMES: &'static [&'static str] = &[];
-    const COLUMN_COUNT: usize = 1;
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        []
+    }
+    fn column_count() -> usize {
+        1
+    }
     const KIND: RowKind = RowKind::Vec;
 
     type Value<'a> = Self;
 }
 
 /// Collects all field names in depth and joins them with comma.
 pub(crate) fn join_column_names<R: Row>() -> Option<String> {
-    if R::COLUMN_NAMES.is_empty() {
+    if R::column_names().into_iter().next().is_none() {
         return None;
     }
 
-    let out = R::COLUMN_NAMES
-        .iter()
-        .enumerate()
-        .fold(String::new(), |mut res, (idx, name)| {
-            if idx > 0 {
-                res.push(',');
-            }
-            sql::escape::identifier(name, &mut res).expect("impossible");
-            res
-        });
+    let out =
+        R::column_names()
+            .into_iter()
+            .enumerate()
+            .fold(String::new(), |mut res, (idx, name)| {
+                if idx > 0 {
+                    res.push(',');
+                }
+                sql::escape::identifier(name, &mut res).expect("impossible");
+                res
+            });
 
     Some(out)
 }
diff --git a/src/row_metadata.rs b/src/row_metadata.rs
@@ -57,13 +57,13 @@ impl RowMetadata {
                 AccessType::WithSeqAccess // ignored
             }
             RowKind::Tuple => {
-                if T::COLUMN_COUNT != columns.len() {
+                if T::column_count() != columns.len() {
                     panic!(
                         "While processing a tuple row: database schema has {} columns, \
                         but the tuple definition has {} fields in total.\
                         \n#### All schema columns:\n{}",
                         columns.len(),
-                        T::COLUMN_COUNT,
+                        T::column_count(),
                         join_panic_schema_hint(&columns),
                     );
                 }
@@ -82,23 +82,25 @@ impl RowMetadata {
                 AccessType::WithSeqAccess // ignored
             }
             RowKind::Struct => {
-                if columns.len() != T::COLUMN_NAMES.len() {
+                if columns.len() != T::column_names().into_iter().count() {
                     panic!(
                         "While processing struct {}: database schema has {} columns, \
                         but the struct definition has {} fields.\
                         \n#### All struct fields:\n{}\n#### All schema columns:\n{}",
                         T::NAME,
                         columns.len(),
-                        T::COLUMN_NAMES.len(),
-                        join_panic_schema_hint(T::COLUMN_NAMES),
+                        T::column_names().into_iter().count(),
+                        join_panic_schema_hint(&T::column_names().into_iter().collect::<Vec<_>>()),
                         join_panic_schema_hint(&columns),
                     );
                 }
-                let mut mapping = Vec::with_capacity(T::COLUMN_NAMES.len());
+                let mut mapping = Vec::with_capacity(T::column_names().into_iter().count());
                 let mut expected_index = 0;
                 let mut should_use_map = false;
                 for col in &columns {
-                    if let Some(index) = T::COLUMN_NAMES.iter().position(|field| col.name == *field)
+                    if let Some(index) = T::column_names()
+                        .into_iter()
+                        .position(|field| col.name == *field)
                     {
                         if index != expected_index {
                             should_use_map = true
@@ -112,7 +114,9 @@ impl RowMetadata {
                             \n#### All struct fields:\n{}\n#### All schema columns:\n{}",
                             T::NAME,
                             col,
-                            join_panic_schema_hint(T::COLUMN_NAMES),
+                            join_panic_schema_hint(
+                                &T::column_names().into_iter().collect::<Vec<_>>()
+                            ),
                             join_panic_schema_hint(&columns),
                         );
                     }
diff --git a/src/rowbinary/tests.rs b/src/rowbinary/tests.rs
@@ -48,30 +48,34 @@ struct Sample<'a> {
 // clickhouse_derive is not working here
 impl Row for Sample<'_> {
     const NAME: &'static str = "Sample";
-    const COLUMN_NAMES: &'static [&'static str] = &[
-        "int8",
-        "int32",
-        "int64",
-        "uint8",
-        "uint32",
-        "uint64",
-        "float32",
-        "float64",
-        "datetime",
-        "datetime64",
-        "time32",
-        "time64",
-        "decimal64",
-        "decimal128",
-        "string",
-        "blob",
-        "optional_decimal64",
-        "optional_datetime",
-        "fixed_string",
-        "array",
-        "boolean",
-    ];
-    const COLUMN_COUNT: usize = 21;
+    fn column_names() -> impl IntoIterator<Item = &'static str> {
+        [
+            "int8",
+            "int32",
+            "int64",
+            "uint8",
+            "uint32",
+            "uint64",
+            "float32",
+            "float64",
+            "datetime",
+            "datetime64",
+            "time32",
+            "time64",
+            "decimal64",
+            "decimal128",
+            "string",
+            "blob",
+            "optional_decimal64",
+            "optional_datetime",
+            "fixed_string",
+            "array",
+            "boolean",
+        ]
+    }
+    fn column_count() -> usize {
+        21
+    }
     const KIND: crate::row::RowKind = crate::row::RowKind::Struct;
 
     type Value<'a> = Sample<'a>;
