Fix test & refactor FieldDef

crates/core/src/db/datastore/locking_tx_datastore/mod.rs

@@ -2968,7 +2968,7 @@ mod tests {
                 IndexDef {
                     columns: NonEmpty::new(1.into()),
                     index_name: "name_idx".into(),
-                    is_unique: true,
+                    is_unique: false,
                     index_type: IndexType::BTree,
                 },
             ])

crates/core/src/sql/ast.rs

@@ -175,14 +175,14 @@ impl From {
 
     /// Returns all the fields matching `f` as a `Vec<FromField>`,
     /// including the ones inside the joins.
-    pub fn find_field(&self, f: &str) -> Result<Vec<FieldDef>, RelationError> {
+    pub fn find_field<'a>(&'a self, f: &'a str) -> Result<Vec<FieldDef>, RelationError> {
         let field = extract_table_field(f)?;
         let fields = self.iter_tables().flat_map(|t| {
             t.columns().iter().filter_map(|column| {
                 if column.col_name == field.field {
                     Some(FieldDef {
-                        column: column.clone(),
-                        table_name: field.table.unwrap_or(&t.table_name).to_string(),
+                        column,
+                        table_name: field.table.unwrap_or(&t.table_name),
                     })
                 } else {
                     None
@@ -195,7 +195,7 @@ impl From {
 
     /// Checks if the field `named` matches exactly once in all the tables
     /// including the ones inside the joins
-    pub fn resolve_field(&self, named: &str) -> Result<FieldDef, PlanError> {
+    pub fn resolve_field<'a>(&'a self, named: &'a str) -> Result<FieldDef, PlanError> {
         let fields = self.find_field(named)?;
 
         match fields.len() {

crates/sats/src/db/def.rs

@@ -279,27 +279,20 @@ impl From<&ColumnSchema> for ProductTypeElement {
 
 /// For get the original `table_name` for where a [ColumnSchema] belongs.
 #[derive(Debug, Clone)]
-pub struct FieldDef {
-    pub column: ColumnSchema,
-    pub table_name: String,
+pub struct FieldDef<'a> {
+    pub column: &'a ColumnSchema,
+    pub table_name: &'a str,
 }
 
-impl From<FieldDef> for FieldName {
+impl From<FieldDef<'_>> for FieldName {
     fn from(value: FieldDef) -> Self {
-        FieldName::named(&value.table_name, &value.column.col_name)
-    }
-}
-
-impl From<&FieldDef> for FieldName {
-    fn from(value: &FieldDef) -> Self {
-        FieldName::named(&value.table_name, &value.column.col_name)
+        FieldName::named(value.table_name, &value.column.col_name)
     }
 }
 
-impl From<FieldDef> for ProductTypeElement {
+impl From<FieldDef<'_>> for ProductTypeElement {
     fn from(value: FieldDef) -> Self {
-        let f: FieldName = (&value).into();
-        ProductTypeElement::new(value.column.col_type, Some(f.to_string()))
+        ProductTypeElement::new(value.column.col_type.clone(), Some(value.column.col_name.clone()))
     }
 }
 
@@ -479,7 +472,7 @@ pub struct TableSchema {
     pub table_type: StTableType,
     pub table_access: StAccess,
     /// Cache for `row_type_for_table` in the data store.
-    pub row_type: ProductType,
+    row_type: ProductType,
 }
 
 impl TableSchema {