fix: column miss match on Insert

Author: KKould

src/catalog/column.rs

@@ -84,7 +84,7 @@ impl ColumnCatalog {
         &self.summary
     }
 
-    pub(crate) fn id(&self) -> Option<ColumnId> {
+    pub fn id(&self) -> Option<ColumnId> {
         match &self.summary.relation {
             ColumnRelation::None => None,
             ColumnRelation::Table { column_id, .. } => Some(*column_id),
@@ -138,17 +138,6 @@ impl ColumnCatalog {
     }
 }
 
-#[cfg(test)]
-impl ColumnSummary {
-    pub(crate) fn column_id(&self) -> Option<&ColumnId> {
-        if let ColumnRelation::Table { column_id, .. } = &self.relation {
-            Some(column_id)
-        } else {
-            None
-        }
-    }
-}
-
 /// The descriptor of a column.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, ReferenceSerialization)]
 pub struct ColumnDesc {

src/db.rs

@@ -399,8 +399,8 @@ pub(crate) mod test {
             true,
             ColumnDesc::new(LogicalType::Integer, false, false, None).unwrap(),
         );
-        let number_column_id = schema[0].summary.column_id().unwrap();
-        column.set_ref_table(Arc::new("a".to_string()), *number_column_id);
+        let number_column_id = schema[0].id().unwrap();
+        column.set_ref_table(Arc::new("a".to_string()), number_column_id);
 
         debug_assert_eq!(schema, Arc::new(vec![ColumnRef::from(column)]));
         debug_assert_eq!(

src/execution/dml/insert.rs

@@ -58,10 +58,10 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
                 let mut tuples = Vec::new();
                 let schema = input.output_schema().clone();
 
-                let pk_index = throw!(schema
+                let pk_name = throw!(schema
                     .iter()
                     .find(|col| col.desc.is_primary)
-                    .map(|col| col.id())
+                    .map(|col| col.name())
                     .ok_or_else(|| DatabaseError::NotNull));
 
                 if let Some(table_catalog) = transaction.table(cache.0, table_name.clone()).cloned()
@@ -74,17 +74,17 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
 
                         let mut tuple_map = HashMap::new();
                         for (i, value) in values.into_iter().enumerate() {
-                            tuple_map.insert(schema[i].id(), value);
+                            tuple_map.insert(schema[i].name(), value);
                         }
                         let tuple_id = throw!(tuple_map
-                            .get(&pk_index)
+                            .get(pk_name)
                             .cloned()
                             .ok_or(DatabaseError::NotNull));
                         let mut values = Vec::with_capacity(table_catalog.columns_len());
 
                         for col in table_catalog.columns() {
                             let value = {
-                                let mut value = tuple_map.remove(&col.id());
+                                let mut value = tuple_map.remove(&col.name());
 
                                 if value.is_none() {
                                     value = throw!(col.default_value());

tests/macros-test/src/main.rs

@@ -171,14 +171,15 @@ mod test {
         );
         assert!(numbers.next().is_none());
 
+        let function_schema = function.output_schema();
         let table_name = Arc::new("test_numbers".to_string());
         let mut c1 = ColumnCatalog::new(
             "c1".to_string(),
             true,
             ColumnDesc::new(LogicalType::Integer, false, false, None)?,
         );
         c1.summary.relation = ColumnRelation::Table {
-            column_id: 0,
+            column_id: function_schema[0].id().unwrap(),
             table_name: table_name.clone(),
         };
         let mut c2 = ColumnCatalog::new(
@@ -187,12 +188,12 @@ mod test {
             ColumnDesc::new(LogicalType::Integer, false, false, None)?,
         );
         c2.summary.relation = ColumnRelation::Table {
-            column_id: 1,
+            column_id: function_schema[1].id().unwrap(),
             table_name: table_name.clone(),
         };
 
         assert_eq!(
-            function.output_schema(),
+            function_schema,
             &Arc::new(vec![ColumnRef::from(c1), ColumnRef::from(c2)])
         );