Fix cargo fmt across workspace

Author: lucidprogrammer

crates/contextdb-cli/src/repl.rs

@@ -81,7 +81,11 @@ pub(crate) fn handle_meta_command(db: &Database, line: &str) -> bool {
 fn print_table_meta(table: &str, meta: &TableMeta) {
     println!("CREATE TABLE {table} (");
     for (idx, col) in meta.columns.iter().enumerate() {
-        let comma = if idx + 1 == meta.columns.len() { "" } else { "," };
+        let comma = if idx + 1 == meta.columns.len() {
+            ""
+        } else {
+            ","
+        };
         let nullable = if col.nullable { "" } else { " NOT NULL" };
         let pk = if col.primary_key { " PRIMARY KEY" } else { "" };
         println!(

crates/contextdb-engine/src/database.rs

@@ -163,7 +163,12 @@ impl Database {
         execute_plan(self, &plan, params, Some(tx))
     }
 
-    pub fn insert_row(&self, tx: TxId, table: &str, values: HashMap<ColName, Value>) -> Result<RowId> {
+    pub fn insert_row(
+        &self,
+        tx: TxId,
+        table: &str,
+        values: HashMap<ColName, Value>,
+    ) -> Result<RowId> {
         self.relational.insert(tx, table, values)
     }
 
@@ -225,7 +230,8 @@ impl Database {
         max_depth: u32,
         snapshot: SnapshotId,
     ) -> Result<TraversalResult> {
-        self.graph.bfs(start, edge_types, direction, 1, max_depth, snapshot)
+        self.graph
+            .bfs(start, edge_types, direction, 1, max_depth, snapshot)
     }
 
     pub fn insert_vector(&self, tx: TxId, row_id: RowId, vector: Vec<f32>) -> Result<()> {

crates/contextdb-engine/src/executor.rs

@@ -63,16 +63,14 @@ pub(crate) fn execute_plan(
             } else {
                 Some(edge_types.as_slice())
             };
-            let res = db
-                .graph()
-                .bfs(
-                    start,
-                    edge_types_ref,
-                    *direction,
-                    *min_depth,
-                    *max_depth,
-                    db.snapshot(),
-                )?;
+            let res = db.graph().bfs(
+                start,
+                edge_types_ref,
+                *direction,
+                *min_depth,
+                *max_depth,
+                db.snapshot(),
+            )?;
 
             Ok(QueryResult {
                 columns: vec!["id".to_string(), "depth".to_string()],
@@ -114,7 +112,9 @@ pub(crate) fn execute_plan(
                 columns: vec!["row_id".to_string(), "score".to_string()],
                 rows: res
                     .into_iter()
-                    .map(|(rid, score)| vec![Value::Int64(rid as i64), Value::Float64(score as f64)])
+                    .map(|(rid, score)| {
+                        vec![Value::Int64(rid as i64), Value::Float64(score as f64)]
+                    })
                     .collect(),
                 rows_affected: 0,
             })
@@ -127,7 +127,9 @@ pub(crate) fn execute_plan(
             }
             Ok(last)
         }
-        _ => Err(Error::PlanError("unsupported plan node in executor".to_string())),
+        _ => Err(Error::PlanError(
+            "unsupported plan node in executor".to_string(),
+        )),
     }
 }
 
@@ -159,19 +161,17 @@ fn exec_insert(
         };
 
         if p.table == "edges"
-            && let (Some(Value::Uuid(source)), Some(Value::Uuid(target)), Some(Value::Text(edge_type))) = (
+            && let (
+                Some(Value::Uuid(source)),
+                Some(Value::Uuid(target)),
+                Some(Value::Text(edge_type)),
+            ) = (
                 values.get("source_id"),
                 values.get("target_id"),
                 values.get("edge_type"),
             )
         {
-            db.insert_edge(
-                txid,
-                *source,
-                *target,
-                edge_type.clone(),
-                HashMap::new(),
-            )?;
+            db.insert_edge(txid, *source, *target, edge_type.clone(), HashMap::new())?;
         }
 
         if let Some(Value::Vector(v)) = values.get("embedding")
@@ -197,7 +197,11 @@ fn exec_delete(
     let rows = db.scan(&p.table, snapshot)?;
     let matched: Vec<_> = rows
         .into_iter()
-        .filter(|r| p.where_clause.as_ref().is_none_or(|w| row_matches(r, w, params).unwrap_or(false)))
+        .filter(|r| {
+            p.where_clause
+                .as_ref()
+                .is_none_or(|w| row_matches(r, w, params).unwrap_or(false))
+        })
         .collect();
 
     for row in &matched {
@@ -218,7 +222,11 @@ fn exec_update(
     let rows = db.scan(&p.table, snapshot)?;
     let matched: Vec<_> = rows
         .into_iter()
-        .filter(|r| p.where_clause.as_ref().is_none_or(|w| row_matches(r, w, params).unwrap_or(false)))
+        .filter(|r| {
+            p.where_clause
+                .as_ref()
+                .is_none_or(|w| row_matches(r, w, params).unwrap_or(false))
+        })
         .collect();
 
     for row in &matched {
@@ -286,7 +294,11 @@ fn row_matches(row: &VersionedRow, expr: &Expr, params: &HashMap<String, Value>)
     }
 }
 
-fn eval_expr_value(row: &VersionedRow, expr: &Expr, params: &HashMap<String, Value>) -> Result<Value> {
+fn eval_expr_value(
+    row: &VersionedRow,
+    expr: &Expr,
+    params: &HashMap<String, Value>,
+) -> Result<Value> {
     match expr {
         Expr::Column(c) => Ok(row.values.get(&c.column).cloned().unwrap_or(Value::Null)),
         _ => resolve_expr(expr, params),
@@ -317,7 +329,9 @@ fn resolve_uuid(expr: &Expr, params: &HashMap<String, Value>) -> Result<uuid::Uu
         Value::Uuid(u) => Ok(u),
         Value::Text(t) => uuid::Uuid::parse_str(&t)
             .map_err(|e| Error::PlanError(format!("invalid uuid '{}': {}", t, e))),
-        _ => Err(Error::PlanError("graph start node must be UUID".to_string())),
+        _ => Err(Error::PlanError(
+            "graph start node must be UUID".to_string(),
+        )),
     }
 }
 
@@ -328,7 +342,9 @@ fn resolve_vector_from_expr(expr: &Expr, params: &HashMap<String, Value>) -> Res
             Some(Value::Vector(v)) => Ok(v.clone()),
             _ => Err(Error::PlanError("vector parameter missing".to_string())),
         },
-        _ => Err(Error::PlanError("invalid vector query expression".to_string())),
+        _ => Err(Error::PlanError(
+            "invalid vector query expression".to_string(),
+        )),
     }
 }
 

crates/contextdb-engine/src/schema_enforcer.rs

@@ -21,7 +21,10 @@ pub fn validate_dml(
                 && let Some(id_idx) = p.columns.iter().position(|c| c == "id")
             {
                 for row in &p.values {
-                    let id_value = row.get(id_idx).map(|e| resolve_expr(e, params)).transpose()?;
+                    let id_value = row
+                        .get(id_idx)
+                        .map(|e| resolve_expr(e, params))
+                        .transpose()?;
                     if let Some(v) = id_value {
                         let lookup = db.point_lookup(&p.table, "id", &v, db.snapshot())?;
                         if lookup.is_some() {
@@ -59,6 +62,8 @@ fn resolve_expr(expr: &Expr, params: &HashMap<String, Value>) -> Result<Value> {
             .cloned()
             .ok_or_else(|| Error::NotFound(format!("missing parameter: {}", p))),
         Expr::Column(c) => Ok(Value::Text(c.column.clone())),
-        _ => Err(Error::PlanError("unsupported expression in schema enforcer".to_string())),
+        _ => Err(Error::PlanError(
+            "unsupported expression in schema enforcer".to_string(),
+        )),
     }
 }