refactor: re-introduce catalog snapshot tests update serde code

The catalog types no longer serialize the id maps, since their info is
intrinsic to the list of schema objects themselves.

influxdb3_catalog/src/catalog.rs

@@ -428,14 +428,12 @@ impl InnerCatalog {
     }
 }
 
-#[serde_with::serde_as]
-#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+#[derive(Debug, Eq, PartialEq, Clone)]
 pub struct DatabaseSchema {
     pub id: DbId,
     pub name: Arc<str>,
     /// The database is a map of tables
     pub tables: SerdeVecMap<TableId, Arc<TableDefinition>>,
-    #[serde_as(as = "TableMapAsArray")]
     pub table_map: BiHashMap<TableId, Arc<str>>,
 }
 
@@ -1091,6 +1089,13 @@ mod tests {
             .databases
             .insert(database.id, Arc::new(database));
 
+        insta::with_settings!({
+            sort_maps => true,
+            description => "catalog serialization to help catch breaking changes"
+        }, {
+            insta::assert_json_snapshot!(catalog);
+        });
+
         // Serialize/deserialize to ensure roundtrip to/from JSON
         let serialized = serde_json::to_string(&catalog).unwrap();
         let deserialized_inner: InnerCatalog = serde_json::from_str(&serialized).unwrap();
@@ -1315,6 +1320,13 @@ mod tests {
             .databases
             .insert(database.id, Arc::new(database));
 
+        insta::with_settings!({
+            sort_maps => true,
+            description => "catalog serialization to help catch breaking changes"
+        }, {
+            insta::assert_json_snapshot!(catalog);
+        });
+
         let serialized = serde_json::to_string(&catalog).unwrap();
         let deserialized_inner: InnerCatalog = serde_json::from_str(&serialized).unwrap();
         let deserialized = Catalog::from_inner(deserialized_inner);
@@ -1372,6 +1384,13 @@ mod tests {
             .databases
             .insert(database.id, Arc::new(database));
 
+        insta::with_settings!({
+            sort_maps => true,
+            description => "catalog serialization to help catch breaking changes"
+        }, {
+            insta::assert_json_snapshot!(catalog);
+        });
+
         let serialized = serde_json::to_string(&catalog).unwrap();
         let deserialized_inner: InnerCatalog = serde_json::from_str(&serialized).unwrap();
         let deserialized = Catalog::from_inner(deserialized_inner);

influxdb3_catalog/src/serialize.rs

@@ -1,8 +1,10 @@
 use crate::catalog::ColumnDefinition;
+use crate::catalog::DatabaseSchema;
 use crate::catalog::TableDefinition;
 use arrow::datatypes::DataType as ArrowDataType;
 use bimap::BiHashMap;
 use influxdb3_id::ColumnId;
+use influxdb3_id::DbId;
 use influxdb3_id::SerdeVecMap;
 use influxdb3_id::TableId;
 use influxdb3_wal::{LastCacheDefinition, LastCacheValueColumnsDef};
@@ -12,6 +14,66 @@ use schema::TIME_DATA_TIMEZONE;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
+impl Serialize for DatabaseSchema {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let snapshot = DatabaseSnapshot::from(self);
+        snapshot.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for DatabaseSchema {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        DatabaseSnapshot::deserialize(deserializer).map(Into::into)
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct DatabaseSnapshot {
+    id: DbId,
+    name: Arc<str>,
+    tables: SerdeVecMap<TableId, TableSnapshot>,
+}
+
+impl From<&DatabaseSchema> for DatabaseSnapshot {
+    fn from(db: &DatabaseSchema) -> Self {
+        Self {
+            id: db.id,
+            name: Arc::clone(&db.name),
+            tables: db
+                .tables
+                .iter()
+                .map(|(table_id, table_def)| (*table_id, table_def.as_ref().into()))
+                .collect(),
+        }
+    }
+}
+
+impl From<DatabaseSnapshot> for DatabaseSchema {
+    fn from(snap: DatabaseSnapshot) -> Self {
+        let mut table_map = BiHashMap::with_capacity(snap.tables.len());
+        let tables = snap
+            .tables
+            .into_iter()
+            .map(|(id, table)| {
+                table_map.insert(id, Arc::clone(&table.table_name));
+                (id, Arc::new(table.into()))
+            })
+            .collect();
+        Self {
+            id: snap.id,
+            name: snap.name,
+            tables,
+            table_map,
+        }
+    }
+}
+
 impl Serialize for TableDefinition {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -48,35 +110,6 @@ struct TableSnapshot {
     last_caches: Vec<LastCacheSnapshot>,
 }
 
-serde_with::serde_conv!(
-    ColumnMapAsArray,
-    BiHashMap<ColumnId, Arc<str>>,
-    |map: &BiHashMap<ColumnId, Arc<str>>| {
-        let mut vec = map.iter().fold(Vec::new(), |mut acc, (id, name)| {
-            acc.push(ColumnMap {
-                column_id: *id,
-                name: Arc::clone(&name)
-            });
-            acc
-        });
-
-        vec.sort_by_key(|col| col.column_id);
-        vec
-    },
-    |vec: Vec<ColumnMap>| -> Result<_, std::convert::Infallible> {
-        Ok(vec.into_iter().fold(BiHashMap::new(), |mut acc, column| {
-            acc.insert(column.column_id, column.name);
-            acc
-        }))
-    }
-);
-
-#[derive(Debug, Serialize, Deserialize)]
-struct ColumnMap {
-    column_id: ColumnId,
-    name: Arc<str>,
-}
-
 /// Representation of Arrow's `DataType` for table snapshots.
 ///
 /// Uses `#[non_exhaustive]` with the assumption that variants will be added as we support