dirsql 0.3.56__tar.gz → 0.3.57__tar.gz

{dirsql-0.3.56 → dirsql-0.3.57}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.56"
+version = "0.3.57"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.56 → dirsql-0.3.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.56
+Version: 0.3.57
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.3.56 → dirsql-0.3.57}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.56"
+version = "0.3.57"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.56 → dirsql-0.3.57}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783101421,
+  "ran_at": 1783105847,
   "exit_code": 0,
-  "commit": "557de9e56c14139d4d35b6ba0aed13c601497d4d"
+  "commit": "d94d40b0448b03171f2e8ffd60635575da1353d5"
 }

{dirsql-0.3.56 → dirsql-0.3.57}/packages/rust/src/db.rs

@@ -301,11 +301,21 @@ impl Db {
     /// The user-row deletes and the matching `_dirsql_internal_rows` mapping
     /// deletes commit in ONE transaction (epic #358), so the mapping never
     /// outlives the rows it describes.
+    ///
+    /// Stage 2 (epic #358): row ownership is read from the mapping, not the
+    /// injected `_dirsql_file_path` column (now write-only). The user rows to
+    /// drop are those whose `rowid` the mapping attributes to `file_path` under
+    /// `table`; the mapping rows are then removed in the same transaction.
     pub fn delete_rows_by_file(&self, table: &str, file_path: &str) -> Result<usize> {
         validate_identifier(table)?;
         let tx = self.conn.unchecked_transaction()?;
-        let sql = format!("DELETE FROM {} WHERE _dirsql_file_path = ?1", table);
-        let count = tx.execute(&sql, [file_path])?;
+        let sql = format!(
+            "DELETE FROM {} WHERE rowid IN \
+             (SELECT rowid_ref FROM _dirsql_internal_rows \
+              WHERE table_name = ?1 AND file_path = ?2)",
+            table
+        );
+        let count = tx.execute(&sql, rusqlite::params![table, file_path])?;
         tx.execute(
             "DELETE FROM _dirsql_internal_rows WHERE table_name = ?1 AND file_path = ?2",
             rusqlite::params![table, file_path],
@@ -1593,6 +1603,71 @@ mod tests {
         db.check_row_mapping_equivalence("t").unwrap();
     }
 
+    #[test]
+    fn delete_rows_by_file_reads_mapping_not_columns() {
+        // Stage 2 (epic #358): delete-by-file resolves ownership through the
+        // mapping, not the now-write-only `_dirsql_file_path` column. Corrupt
+        // the column so it disagrees with the mapping and confirm the delete
+        // still follows the mapping.
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t (id TEXT)").unwrap();
+        db.insert_row(
+            "t",
+            &HashMap::from([("id".into(), Value::Text("a".into()))]),
+            "real.json",
+            0,
+        )
+        .unwrap();
+        // Desync the write-only column from the mapping.
+        db.conn
+            .execute("UPDATE t SET _dirsql_file_path = 'wrong.json'", [])
+            .unwrap();
+
+        // Deleting by the mapping's file removes the row; deleting by the
+        // stale column value is a no-op.
+        assert_eq!(db.delete_rows_by_file("t", "wrong.json").unwrap(), 0);
+        assert_eq!(db.delete_rows_by_file("t", "real.json").unwrap(), 1);
+        let remaining: i64 = db
+            .conn
+            .query_row("SELECT COUNT(*) FROM t", [], |r| r.get(0))
+            .unwrap();
+        assert_eq!(remaining, 0);
+        db.check_row_mapping_equivalence("t").unwrap();
+    }
+
+    #[test]
+    fn delete_rows_by_file_is_scoped_to_its_table() {
+        // The mapping subquery is keyed on (table_name, file_path): a delete on
+        // one table must not touch another table's rows for the same file path,
+        // even when they share a rowid.
+        let db = Db::new().unwrap();
+        db.create_table("CREATE TABLE t1 (id TEXT)").unwrap();
+        db.create_table("CREATE TABLE t2 (id TEXT)").unwrap();
+        db.insert_row(
+            "t1",
+            &HashMap::from([("id".into(), Value::Text("x".into()))]),
+            "shared.json",
+            0,
+        )
+        .unwrap();
+        db.insert_row(
+            "t2",
+            &HashMap::from([("id".into(), Value::Text("y".into()))]),
+            "shared.json",
+            0,
+        )
+        .unwrap();
+
+        assert_eq!(db.delete_rows_by_file("t1", "shared.json").unwrap(), 1);
+        let t2_rows: i64 = db
+            .conn
+            .query_row("SELECT COUNT(*) FROM t2", [], |r| r.get(0))
+            .unwrap();
+        assert_eq!(t2_rows, 1, "t2's row for the same path must be untouched");
+        db.check_row_mapping_equivalence("t1").unwrap();
+        db.check_row_mapping_equivalence("t2").unwrap();
+    }
+
     #[test]
     fn failed_row_insert_leaves_no_mapping_row() {
         // Transactional coupling, forward direction: when the user-row insert

{dirsql-0.3.56 → dirsql-0.3.57}/packages/rust/src/persist.rs

@@ -384,9 +384,15 @@ pub fn drop_user_tables(conn: &Connection) -> rusqlite::Result<()> {
     Ok(())
 }
 
-/// Look up the existing `dirsql_*` tracking column rows for one file. Used
-/// on warm start to rebuild the in-memory `file_rows` cache that the
-/// watcher's diffing path requires.
+/// Look up the row store's rows for one file, ordered by row index. Used on
+/// warm start to rebuild the in-memory `file_rows` cache that the watcher's
+/// diffing path requires.
+///
+/// Stage 2 (epic #358): ownership and ordering are read from the
+/// `_dirsql_internal_rows` mapping (joined on `rowid`), not the injected
+/// `_dirsql_file_path` / `_dirsql_row_index` columns (now write-only). User
+/// columns are qualified with the table alias so a user column named like a
+/// mapping column stays unambiguous.
 pub fn read_rows_for_file(
     conn: &Connection,
     table: &str,
@@ -395,17 +401,19 @@ pub fn read_rows_for_file(
 ) -> rusqlite::Result<Vec<HashMap<String, crate::db::Value>>> {
     let mut col_list = user_columns
         .iter()
-        .map(|c| format!("\"{c}\""))
+        .map(|c| format!("t.\"{c}\""))
         .collect::<Vec<_>>()
         .join(", ");
     if col_list.is_empty() {
         col_list = "1".to_string();
     }
     let sql = format!(
-        "SELECT {col_list} FROM \"{table}\" WHERE _dirsql_file_path = ?1 ORDER BY _dirsql_row_index"
+        "SELECT {col_list} FROM \"{table}\" AS t \
+         JOIN _dirsql_internal_rows AS m ON m.rowid_ref = t.rowid \
+         WHERE m.table_name = ?1 AND m.file_path = ?2 ORDER BY m.row_index"
     );
     let mut stmt = conn.prepare(&sql)?;
-    let rows = stmt.query_map(params![rel_path], |row| {
+    let rows = stmt.query_map(params![table, rel_path], |row| {
         let mut map = HashMap::new();
         for (i, name) in user_columns.iter().enumerate() {
             let v: rusqlite::types::Value = row.get(i)?;
@@ -673,6 +681,18 @@ mod tests {
         assert_eq!(system_time_to_ns(None), 0);
     }
 
+    /// Declare the internal mapping table on a raw connection (the `db` helper
+    /// would break unit isolation). Stage 2 reads through this table.
+    fn create_internal_rows_table(conn: &Connection) {
+        conn.execute(
+            "CREATE TABLE _dirsql_internal_rows (
+                table_name TEXT NOT NULL, file_path TEXT NOT NULL,
+                row_index INTEGER NOT NULL, rowid_ref INTEGER NOT NULL)",
+            [],
+        )
+        .unwrap();
+    }
+
     #[test]
     fn read_rows_for_file_handles_empty_user_columns() {
         // With no user columns the SELECT list collapses to `1`, so the
@@ -683,11 +703,19 @@ mod tests {
             [],
         )
         .unwrap();
+        create_internal_rows_table(&conn);
         conn.execute(
             "INSERT INTO rows (_dirsql_file_path, _dirsql_row_index) VALUES ('f.csv', 0), ('f.csv', 1)",
             [],
         )
         .unwrap();
+        // Map the two inserted rows (rowids 1, 2) to f.csv.
+        conn.execute(
+            "INSERT INTO _dirsql_internal_rows (table_name, file_path, row_index, rowid_ref) \
+             VALUES ('rows', 'f.csv', 0, 1), ('rows', 'f.csv', 1, 2)",
+            [],
+        )
+        .unwrap();
         let rows = read_rows_for_file(&conn, "rows", "f.csv", &[]).unwrap();
         assert_eq!(rows.len(), 2);
         assert!(rows[0].is_empty());
@@ -701,17 +729,59 @@ mod tests {
             [],
         )
         .unwrap();
+        create_internal_rows_table(&conn);
         conn.execute(
             "INSERT INTO rows (col, _dirsql_file_path, _dirsql_row_index) VALUES ('a', 'f.csv', 0), ('b', 'f.csv', 1), ('c', 'g.csv', 0)",
             [],
         )
         .unwrap();
+        // rowids 1, 2 belong to f.csv; rowid 3 to g.csv.
+        conn.execute(
+            "INSERT INTO _dirsql_internal_rows (table_name, file_path, row_index, rowid_ref) \
+             VALUES ('rows', 'f.csv', 0, 1), ('rows', 'f.csv', 1, 2), ('rows', 'g.csv', 0, 3)",
+            [],
+        )
+        .unwrap();
         let rows = read_rows_for_file(&conn, "rows", "f.csv", &["col".to_string()]).unwrap();
         assert_eq!(rows.len(), 2);
         assert_eq!(rows[0]["col"], crate::db::Value::Text("a".into()));
         assert_eq!(rows[1]["col"], crate::db::Value::Text("b".into()));
     }
 
+    #[test]
+    fn read_rows_for_file_reads_mapping_not_columns() {
+        // Stage 2: ownership + ordering come from the mapping, not the
+        // write-only injected columns. Store a row whose `_dirsql_file_path` /
+        // `_dirsql_row_index` columns DISAGREE with the mapping, and confirm
+        // the read follows the mapping.
+        let conn = Connection::open_in_memory().unwrap();
+        conn.execute(
+            "CREATE TABLE rows (col TEXT, _dirsql_file_path TEXT, _dirsql_row_index INTEGER)",
+            [],
+        )
+        .unwrap();
+        create_internal_rows_table(&conn);
+        // Column says wrong.csv / index 9; mapping says right.csv / index 0.
+        conn.execute(
+            "INSERT INTO rows (col, _dirsql_file_path, _dirsql_row_index) VALUES ('a', 'wrong.csv', 9)",
+            [],
+        )
+        .unwrap();
+        conn.execute(
+            "INSERT INTO _dirsql_internal_rows (table_name, file_path, row_index, rowid_ref) \
+             VALUES ('rows', 'right.csv', 0, 1)",
+            [],
+        )
+        .unwrap();
+        // Querying the mapping's file returns the row...
+        let hit = read_rows_for_file(&conn, "rows", "right.csv", &["col".to_string()]).unwrap();
+        assert_eq!(hit.len(), 1);
+        assert_eq!(hit[0]["col"], crate::db::Value::Text("a".into()));
+        // ...and the column's (stale) file returns nothing.
+        let miss = read_rows_for_file(&conn, "rows", "wrong.csv", &["col".to_string()]).unwrap();
+        assert!(miss.is_empty());
+    }
+
     // --- rusqlite error propagation (`?` arms) ---
     //
     // Each sidecar accessor runs against a `_dirsql_*` table. Calling it on a