Fix memory accounting, update validation, and vector exclusion regressions

Author: lucidprogrammer

crates/contextdb-core/src/types.rs

@@ -50,7 +50,7 @@ impl Value {
                 if s.len() <= 16 {
                     32 + s.len().saturating_mul(8)
                 } else {
-                    48 + s.len().saturating_mul(2)
+                    160 + s.len().saturating_mul(72)
                 }
             }
             Value::Uuid(_) => 32,

crates/contextdb-engine/src/database.rs

@@ -1087,14 +1087,8 @@ impl Database {
             if trigger_state != source.state {
                 continue;
             }
-            if let Some(row) = self.relational.point_lookup_with_tx(
-                Some(ctx.tx),
-                source.table,
-                "id",
-                &Value::Uuid(source.uuid),
-                ctx.snapshot,
-            )? {
-                self.delete_vector(ctx.tx, row.row_id)?;
+            for row_id in self.logical_row_ids_for_uuid(ctx.tx, source.table, source.uuid) {
+                self.delete_vector(ctx.tx, row_id)?;
             }
         }
 
@@ -1140,6 +1134,33 @@ impl Database {
             .point_lookup_with_tx(Some(tx), table, col, value, snapshot)
     }
 
+    pub(crate) fn logical_row_ids_for_uuid(
+        &self,
+        tx: TxId,
+        table: &str,
+        uuid: uuid::Uuid,
+    ) -> Vec<RowId> {
+        let mut row_ids = HashSet::new();
+
+        if let Some(rows) = self.relational_store.tables.read().get(table) {
+            for row in rows {
+                if row.values.get("id") == Some(&Value::Uuid(uuid)) {
+                    row_ids.insert(row.row_id);
+                }
+            }
+        }
+
+        let _ = self.tx_mgr.with_write_set(tx, |ws| {
+            for (insert_table, row) in &ws.relational_inserts {
+                if insert_table == table && row.values.get("id") == Some(&Value::Uuid(uuid)) {
+                    row_ids.insert(row.row_id);
+                }
+            }
+        });
+
+        row_ids.into_iter().collect()
+    }
+
     pub fn insert_edge(
         &self,
         tx: TxId,

crates/contextdb-engine/src/executor.rs

@@ -1086,6 +1086,7 @@ fn exec_update(
             let value = eval_assignment_expr(vexpr, &row.values, params)?;
             values.insert(k.clone(), coerce_value_for_column(db, &p.table, k, value)?);
         }
+        validate_update_state_transition(db, &p.table, row, &values)?;
         let row_uuid = values.get("id").and_then(Value::as_uuid).copied();
         let new_state = db
             .table_meta(&p.table)
@@ -1155,6 +1156,44 @@ fn estimate_table_row_bytes(
     Ok(estimate_row_bytes_for_meta(values, &meta, false))
 }
 
+fn validate_update_state_transition(
+    db: &Database,
+    table: &str,
+    existing: &VersionedRow,
+    next_values: &HashMap<String, Value>,
+) -> Result<()> {
+    let Some(meta) = db.table_meta(table) else {
+        return Ok(());
+    };
+    let Some(state_machine) = meta.state_machine else {
+        return Ok(());
+    };
+
+    let old_state = existing
+        .values
+        .get(&state_machine.column)
+        .and_then(Value::as_text);
+    let new_state = next_values
+        .get(&state_machine.column)
+        .and_then(Value::as_text);
+
+    let (Some(old_state), Some(new_state)) = (old_state, new_state) else {
+        return Ok(());
+    };
+
+    if old_state == new_state
+        || db
+            .relational_store()
+            .validate_state_transition(table, &state_machine.column, old_state, new_state)
+    {
+        return Ok(());
+    }
+
+    Err(Error::InvalidStateTransition(format!(
+        "{old_state} -> {new_state}"
+    )))
+}
+
 fn estimate_row_bytes_for_meta(
     values: &HashMap<String, Value>,
     meta: &TableMeta,