dirsql 0.4.104__tar.gz → 0.4.105__tar.gz

{dirsql-0.4.104 → dirsql-0.4.105}/Cargo.lock

@@ -573,7 +573,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql"
-version = "0.4.104"
+version = "0.4.105"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.104"
+version = "0.4.105"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.104 → dirsql-0.4.105}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.104
+Version: 0.4.105
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.104 → dirsql-0.4.105}/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.4.104"
+version = "0.4.105"
 # abi3 note: the `abi3-py310` pyo3 feature (below) builds ONE stable-ABI
 # `cp310-abi3` wheel per platform that loads on every CPython >= 3.10
 # (matching `pyproject.toml`'s `requires-python = ">=3.10"`), instead of

dirsql-0.4.105/packages/python/e2e-attestations/bot-1457-incremental-refresh-1008.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/on_file_query_test.py tests/e2e/query_contract_test.py tests/e2e/use_case_transcripts_test.py -x -q",
+  "ran_at": 1791462122,
+  "exit_code": 0,
+  "commit": "e59418c942479166b7edd1a1587ed559574c60b7",
+  "branch": "bot/1457-incremental-refresh-1008"
+}

{dirsql-0.4.104 → dirsql-0.4.105}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.104"
+version = "0.4.105"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.104 → dirsql-0.4.105}/packages/rust/src/db.rs

@@ -266,6 +266,28 @@ pub fn ensure_internal_rows_table(conn: &Connection) -> rusqlite::Result<()> {
     )
 }
 
+fn insert_sql(table: &str, columns: &[String]) -> String {
+    if columns.is_empty() {
+        return format!("INSERT INTO \"{table}\" DEFAULT VALUES");
+    }
+    let names: Vec<String> = columns.iter().map(|c| format!("\"{c}\"")).collect();
+    let placeholders: Vec<String> = (1..=columns.len()).map(|i| format!("?{i}")).collect();
+    format!(
+        "INSERT INTO \"{table}\" ({}) VALUES ({})",
+        names.join(", "),
+        placeholders.join(", ")
+    )
+}
+
+/// The rows a [`Db::reconcile_batch_rows`] did not carry over: those only the
+/// table held (`removed`) and those only the new rows hold (`added`), each in
+/// its original order.
+#[derive(Debug, Default)]
+pub struct RowChanges {
+    pub removed: Vec<HashMap<String, Value>>,
+    pub added: Vec<HashMap<String, Value>>,
+}
+
 /// A batch of rows laid out in a table's DDL column order, so each row binds
 /// positionally with no per-cell lookup.
 #[derive(Debug, Clone, PartialEq)]
@@ -700,18 +722,7 @@ impl Db {
     /// interleave batches of different owners.
     pub fn insert_rows(&self, table: &str, rows: &ShapedRows, file_path: &str) -> Result<()> {
         validate_identifier(table)?;
-        let columns = &rows.columns;
-        let sql = if columns.is_empty() {
-            format!("INSERT INTO \"{table}\" DEFAULT VALUES")
-        } else {
-            let names: Vec<String> = columns.iter().map(|c| format!("\"{c}\"")).collect();
-            let placeholders: Vec<String> = (1..=columns.len()).map(|i| format!("?{i}")).collect();
-            format!(
-                "INSERT INTO \"{table}\" ({}) VALUES ({})",
-                names.join(", "),
-                placeholders.join(", ")
-            )
-        };
+        let sql = insert_sql(table, &rows.columns);
         let tx = if self.conn.is_autocommit() {
             Some(self.conn.unchecked_transaction()?)
         } else {
@@ -743,6 +754,99 @@ impl Db {
         Ok(())
     }
 
+    /// Make the table's rows, all owned by the batch `owner`, equal `rows`,
+    /// writing only the difference. The rows are compared as a multiset (a
+    /// batch has no row identity): an equal row already stored is left in
+    /// place, a stored row with no match is deleted, and a new row with no
+    /// match is inserted. The owner's rowid range is then re-fitted to the
+    /// table. Run it inside the caller's transaction.
+    pub fn reconcile_batch_rows(
+        &self,
+        table: &str,
+        owner: &str,
+        rows: &ShapedRows,
+    ) -> Result<RowChanges> {
+        validate_identifier(table)?;
+        let columns = &rows.columns;
+        let select = if columns.is_empty() {
+            format!("SELECT rowid FROM \"{table}\" ORDER BY rowid")
+        } else {
+            let names: Vec<String> = columns.iter().map(|c| format!("\"{c}\"")).collect();
+            format!(
+                "SELECT rowid, {} FROM \"{table}\" ORDER BY rowid",
+                names.join(", ")
+            )
+        };
+        let mut stored: Vec<(i64, Vec<Value>)> = Vec::new();
+        {
+            let mut stmt = self.conn.prepare(&select)?;
+            let mut cursor = stmt.query([])?;
+            while let Some(row) = cursor.next()? {
+                let cells = (0..columns.len())
+                    .map(|i| row.get::<_, rusqlite::types::Value>(i + 1).map(Value::from))
+                    .collect::<rusqlite::Result<Vec<_>>>()?;
+                stored.push((row.get(0)?, cells));
+            }
+        }
+        let mut unclaimed: HashMap<String, Vec<usize>> = HashMap::new();
+        for (index, (_, cells)) in stored.iter().enumerate().rev() {
+            unclaimed
+                .entry(format!("{cells:?}"))
+                .or_default()
+                .push(index);
+        }
+        let mut added = Vec::new();
+        for (index, cells) in rows.cells.iter().enumerate() {
+            match unclaimed.get_mut(&format!("{cells:?}")) {
+                Some(indexes) if !indexes.is_empty() => {
+                    indexes.pop();
+                }
+                _ => added.push(index),
+            }
+        }
+        let mut removed: Vec<usize> = unclaimed.into_values().flatten().collect();
+        removed.sort_unstable();
+
+        let to_map = |cells: &[Value]| -> HashMap<String, Value> {
+            columns.iter().cloned().zip(cells.iter().cloned()).collect()
+        };
+        let changes = RowChanges {
+            removed: removed.iter().map(|&i| to_map(&stored[i].1)).collect(),
+            added: added.iter().map(|&i| to_map(&rows.cells[i])).collect(),
+        };
+        if removed.is_empty() && added.is_empty() {
+            return Ok(changes);
+        }
+        let mut delete = self
+            .conn
+            .prepare_cached(&format!("DELETE FROM \"{table}\" WHERE rowid = ?1"))?;
+        for &index in &removed {
+            delete.execute([stored[index].0])?;
+        }
+        let mut insert = self.conn.prepare_cached(&insert_sql(table, columns))?;
+        for &index in &added {
+            for (i, value) in rows.cells[index].iter().enumerate() {
+                insert.raw_bind_parameter(i + 1, value)?;
+            }
+            insert.raw_execute()?;
+        }
+        self.conn.execute(
+            "DELETE FROM _dirsql_internal_ranges WHERE table_name = ?1 AND file_path = ?2",
+            rusqlite::params![table, owner],
+        )?;
+        let (first, last): (Option<i64>, Option<i64>) = self.conn.query_row(
+            &format!("SELECT min(rowid), max(rowid) FROM \"{table}\""),
+            [],
+            |r| Ok((r.get(0)?, r.get(1)?)),
+        )?;
+        if let (Some(first), Some(last)) = (first, last) {
+            self.conn
+                .prepare_cached(RANGE_INSERT)?
+                .execute(rusqlite::params![table, owner, first, last])?;
+        }
+        Ok(changes)
+    }
+
     /// Both the table name and every user-provided column name are validated
     /// as safe SQL identifiers before being interpolated. A column key with
     /// SQL syntax (e.g. `id); DROP TABLE t; --`) produces a clean
@@ -3023,6 +3127,141 @@ mod tests {
         assert!(range_rows(&db, "t").is_empty());
     }
 
+    fn table_rows(db: &Db, table: &str) -> Vec<(i64, String)> {
+        db.conn()
+            .prepare(&format!("SELECT rowid, id FROM {table} ORDER BY rowid"))
+            .unwrap()
+            .query_map([], |r| Ok((r.get(0)?, r.get(1)?)))
+            .unwrap()
+            .collect::<rusqlite::Result<_>>()
+            .unwrap()
+    }
+
+    fn ids(changes: &[HashMap<String, Value>]) -> Vec<Value> {
+        changes.iter().map(|row| row["id"].clone()).collect()
+    }
+
+    fn batch_db(ids: serde_json::Value) -> Db {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (id TEXT)").unwrap();
+        db.insert_rows("t", &shaped(&db, "t", ids), "").unwrap();
+        db
+    }
+
+    #[test]
+    fn reconcile_batch_rows_leaves_equal_rows_in_place_and_writes_the_rest() {
+        let db = batch_db(serde_json::json!([{"id":"a"},{"id":"b"},{"id":"c"}]));
+        let next = shaped(
+            &db,
+            "t",
+            serde_json::json!([{"id":"a"},{"id":"x"},{"id":"c"}]),
+        );
+        let before = db.conn().total_changes();
+
+        let changes = db.reconcile_batch_rows("t", "", &next).unwrap();
+
+        assert_eq!(
+            table_rows(&db, "t"),
+            vec![(1, "a".into()), (3, "c".into()), (4, "x".into())]
+        );
+        assert_eq!(ids(&changes.removed), vec![Value::Text("b".into())]);
+        assert_eq!(ids(&changes.added), vec![Value::Text("x".into())]);
+        assert_eq!(db.conn().total_changes() - before, 4);
+    }
+
+    #[test]
+    fn reconcile_batch_rows_compares_rows_as_a_multiset() {
+        let db = batch_db(serde_json::json!([{"id":"a"},{"id":"a"},{"id":"a"}]));
+        let next = shaped(&db, "t", serde_json::json!([{"id":"a"},{"id":"a"}]));
+
+        let changes = db.reconcile_batch_rows("t", "", &next).unwrap();
+
+        assert_eq!(table_rows(&db, "t"), vec![(1, "a".into()), (2, "a".into())]);
+        assert_eq!(ids(&changes.removed), vec![Value::Text("a".into())]);
+        assert!(changes.added.is_empty());
+    }
+
+    #[test]
+    fn reconcile_batch_rows_inserts_each_copy_the_table_holds_too_few_of() {
+        let db = batch_db(serde_json::json!([{"id":"a"}]));
+        let next = shaped(
+            &db,
+            "t",
+            serde_json::json!([{"id":"a"},{"id":"a"},{"id":"a"}]),
+        );
+
+        let changes = db.reconcile_batch_rows("t", "", &next).unwrap();
+
+        assert_eq!(
+            table_rows(&db, "t"),
+            vec![(1, "a".into()), (2, "a".into()), (3, "a".into())]
+        );
+        assert_eq!(ids(&changes.added).len(), 2);
+        assert!(changes.removed.is_empty());
+    }
+
+    #[test]
+    fn reconcile_batch_rows_writes_nothing_when_no_row_changed() {
+        let db = batch_db(serde_json::json!([{"id":"a"},{"id":"b"}]));
+        let same = shaped(&db, "t", serde_json::json!([{"id":"b"},{"id":"a"}]));
+        let before = db.conn().total_changes();
+
+        let changes = db.reconcile_batch_rows("t", "", &same).unwrap();
+
+        assert!(changes.removed.is_empty() && changes.added.is_empty());
+        assert_eq!(db.conn().total_changes(), before);
+    }
+
+    #[test]
+    fn reconcile_batch_rows_refits_the_owners_range_to_the_table() {
+        let db = batch_db(serde_json::json!([{"id":"a"},{"id":"b"},{"id":"c"}]));
+        let next = shaped(&db, "t", serde_json::json!([{"id":"b"},{"id":"d"}]));
+        db.reconcile_batch_rows("t", "", &next).unwrap();
+
+        assert_eq!(range_rows(&db, "t"), vec![(String::new(), 2, 3)]);
+        let read: Vec<Value> = db
+            .get_rows_by_file("t", "")
+            .unwrap()
+            .into_iter()
+            .map(|r| r["id"].clone())
+            .collect();
+        assert_eq!(read, vec![Value::Text("b".into()), Value::Text("d".into())]);
+
+        let empty = shaped(&db, "t", serde_json::json!([]));
+        db.reconcile_batch_rows("t", "", &empty).unwrap();
+        assert!(range_rows(&db, "t").is_empty());
+        assert!(table_rows(&db, "t").is_empty());
+    }
+
+    #[test]
+    fn reconcile_batch_rows_binds_an_empty_column_list_by_default_values() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (id TEXT)").unwrap();
+        let rows = ShapedRows {
+            columns: vec![],
+            cells: vec![vec![]],
+        };
+        db.reconcile_batch_rows("t", "", &rows).unwrap();
+        assert_eq!(table_rows_count(&db), 1);
+    }
+
+    fn table_rows_count(db: &Db) -> i64 {
+        db.conn()
+            .query_row("SELECT count(*) FROM t", [], |r| r.get(0))
+            .unwrap()
+    }
+
+    #[test]
+    fn reconcile_batch_rows_rejects_an_unsafe_table_name() {
+        let db = Db::new().unwrap();
+        let rows = ShapedRows {
+            columns: vec![],
+            cells: vec![],
+        };
+        let err = db.reconcile_batch_rows("bad name", "", &rows).unwrap_err();
+        assert!(matches!(err, DbError::InvalidIdentifier(_)), "got: {err}");
+    }
+
     #[test]
     fn insert_rows_rejects_an_unsafe_table_name() {
         let db = Db::new().unwrap();

{dirsql-0.4.104 → dirsql-0.4.105}/packages/rust/src/lib.rs

@@ -755,6 +755,8 @@ impl DirSQL {
 
             for m in matches {
                 if self.is_per_table(&m.table_name) {
+                    let deleted = matches!(event, FileEvent::Deleted(_));
+                    self.track_batch_file(&m.table_name, &abs_path, &rel_path, deleted);
                     pending.mark(&m.table_name, &rel_path);
                     continue;
                 }
@@ -832,22 +834,20 @@ impl DirSQL {
         else {
             return Vec::new();
         };
-        let root = &group.anchor;
-        let mut rel_paths = Vec::new();
-        let mut abs_paths = Vec::new();
-        for (path, matched) in self.inner.fs.scan_subtree(root, root, &group.matcher) {
-            if matched == table {
-                rel_paths.push(relative_path(root, &path));
-                abs_paths.push(path);
-            }
-        }
+        let abs_paths: Vec<PathBuf> = match self.inner.batch_files.lock() {
+            Ok(files) => files
+                .get(table)
+                .map(|rel_paths| rel_paths.iter().map(|rel| group.anchor.join(rel)).collect())
+                .unwrap_or_default(),
+            Err(e) => return vec![error_event(Some(table), trigger, e.to_string())],
+        };
         let raw_rows = match collect_table_rows(hook.as_ref(), &abs_paths) {
             Ok(rows) => rows,
             Err(e) => return vec![error_event(Some(table), trigger, e.to_string())],
         };
         let strict = *self.inner.strict_map.get(table).unwrap_or(&false);
 
-        let (old_rows, new_rows) = {
+        let changes = {
             let db = match self.inner.db.lock() {
                 Ok(g) => g,
                 Err(e) => return vec![error_event(Some(table), trigger, e.to_string())],
@@ -856,27 +856,41 @@ impl DirSQL {
                 Ok(rows) => rows,
                 Err(message) => return vec![error_event(Some(table), trigger, message)],
             };
-            let old_rows = match db.get_rows_by_file(table, BATCH_OWNER) {
-                Ok(rows) => rows,
-                Err(e) => return vec![error_event(Some(table), trigger, e.to_string())],
-            };
             let _tx = match db.conn().unchecked_transaction() {
                 Ok(tx) => tx,
                 Err(e) => return vec![error_event(Some(table), trigger, e.to_string())],
             };
-            if let Err(e) = replace_table_rows(&db, table, &new_rows) {
-                return vec![error_event(Some(table), trigger, e.to_string())];
-            }
+            let changes = match db.reconcile_batch_rows(table, BATCH_OWNER, &new_rows) {
+                Ok(changes) => changes,
+                Err(e) => return vec![error_event(Some(table), trigger, e.to_string())],
+            };
             if let Err(e) = _tx.commit() {
                 return vec![error_event(Some(table), trigger, e.to_string())];
             }
-            (old_rows, new_rows.to_maps())
+            changes
         };
-        if let Ok(mut files) = self.inner.batch_files.lock() {
-            files.insert(table.to_string(), rel_paths);
-        }
 
-        differ::diff_unordered(table, &old_rows, &new_rows, trigger)
+        differ::diff_unordered(table, &changes.removed, &changes.added, trigger)
+    }
+
+    /// Record in the table's file set whether `abs_path` is, now, one of the
+    /// files its per-table hook runs over. The set stays in walk order
+    /// (component-wise byte order), so the hook sees the same argument list a
+    /// walk of the tree would give it.
+    fn track_batch_file(&self, table: &str, abs_path: &Path, rel_path: &str, deleted: bool) {
+        let present = !deleted && self.inner.fs.is_file(abs_path).unwrap_or(false);
+        let Ok(mut batch_files) = self.inner.batch_files.lock() else {
+            return;
+        };
+        let files = batch_files.entry(table.to_string()).or_default();
+        let at = files.binary_search_by(|file| Path::new(file).cmp(Path::new(rel_path)));
+        match (present, at) {
+            (true, Err(at)) => files.insert(at, rel_path.to_string()),
+            (false, Ok(at)) => {
+                files.remove(at);
+            }
+            _ => {}
+        }
     }
 
     /// Delete the rows of every file recorded beneath `rel_dir`, in every
@@ -889,9 +903,10 @@ impl DirSQL {
     ) -> Vec<RowEvent> {
         let prefix = format!("{rel_dir}/");
         let in_group = |table: &str| group.tables.iter().any(|name| name == table);
-        if let Ok(batch_files) = self.inner.batch_files.lock() {
-            for (table, files) in batch_files.iter() {
+        if let Ok(mut batch_files) = self.inner.batch_files.lock() {
+            for (table, files) in batch_files.iter_mut() {
                 if in_group(table) && files.iter().any(|file| file.starts_with(&prefix)) {
+                    files.retain(|file| !file.starts_with(&prefix));
                     pending.mark(table, rel_dir);
                 }
             }
@@ -934,6 +949,7 @@ impl DirSQL {
         for (path, table) in self.inner.fs.scan_subtree(base, dir, &group.matcher) {
             let rel_path = scanner::to_slash(path.strip_prefix(base).unwrap_or(&path));
             if self.is_per_table(&table) {
+                self.track_batch_file(&table, &path, &rel_path, false);
                 pending.mark(&table, &rel_path);
                 continue;
             }
@@ -2344,12 +2360,6 @@ fn stream_table_rows(
     })
 }
 
-/// Replace a per-table hook's rows wholesale under [`BATCH_OWNER`].
-fn replace_table_rows(db: &Db, table: &str, rows: &ShapedRows) -> db::Result<()> {
-    db.delete_rows_by_file(table, BATCH_OWNER)?;
-    db.insert_rows(table, rows, BATCH_OWNER)
-}
-
 fn error_event(table: Option<&str>, rel_path: &str, error: String) -> RowEvent {
     RowEvent::Error {
         table: table.map(str::to_string),
@@ -5402,6 +5412,157 @@ mod internal_tests {
         assert_eq!(row_names(&db), vec!["a.txt", "b.txt"]);
     }
 
+    #[test]
+    fn apply_file_events_refreshes_a_per_table_hook_without_walking_the_tree() {
+        let dir = TempDir::new().unwrap();
+        let root = dir.path().to_path_buf();
+        let a = root.join("a.txt");
+        let b = root.join("b.txt");
+        let fake = Arc::new(FakeFs::default().with_subtree(
+            root.clone(),
+            vec![(a.clone(), "items".into()), (b.clone(), "items".into())],
+        ));
+        let (items, calls) = recording_per_table("items", "**/*.txt");
+        let db = DirSQL::with_ignore_and_fs(&root, vec![items], Vec::<String>::new(), fake.clone())
+            .unwrap();
+
+        db.apply_file_events(vec![
+            FileEvent::Created(b.clone()),
+            FileEvent::Created(a.clone()),
+        ]);
+        db.apply_file_events(vec![FileEvent::Modified(a.clone())]);
+        db.apply_file_events(vec![FileEvent::Deleted(a.clone())]);
+
+        assert_eq!(
+            fake.subtree_walks(),
+            Vec::<PathBuf>::new(),
+            "a file event must not re-walk the tree"
+        );
+        assert_eq!(
+            *calls.lock().unwrap(),
+            vec![vec![a.clone(), b.clone()], vec![a, b.clone()], vec![b]]
+        );
+    }
+
+    #[test]
+    fn apply_file_events_writes_only_the_rows_a_per_table_refresh_changed() {
+        let dir = TempDir::new().unwrap();
+        let root = dir.path().to_path_buf();
+        let paths: Vec<PathBuf> = (0..20).map(|i| root.join(format!("f{i:02}.txt"))).collect();
+        let found = paths.iter().map(|p| (p.clone(), "items".into())).collect();
+        let fake = Arc::new(FakeFs::default().with_subtree(root.clone(), found));
+        let runs = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let counted = Arc::clone(&runs);
+        let items = Table::per_table(
+            "items",
+            "CREATE TABLE items (name TEXT)",
+            "**/*.txt",
+            move |paths: &[PathBuf]| {
+                let run = counted.fetch_add(1, Ordering::SeqCst);
+                Ok(paths
+                    .iter()
+                    .map(|p| {
+                        let name = p.file_name().unwrap().to_string_lossy().into_owned();
+                        name_json_row(&if name == "f00.txt" {
+                            format!("{name}#{run}")
+                        } else {
+                            name
+                        })
+                    })
+                    .collect())
+            },
+        );
+        let db =
+            DirSQL::with_ignore_and_fs(&root, vec![items], Vec::<String>::new(), fake).unwrap();
+        db.apply_file_events(paths.iter().cloned().map(FileEvent::Created).collect());
+        let written = || db.inner.db.lock().unwrap().conn().total_changes();
+        let before = written();
+
+        let events = db.apply_file_events(vec![FileEvent::Modified(paths[0].clone())]);
+
+        assert_eq!(events.len(), 1, "{events:?}");
+        let delta = written() - before;
+        assert!(delta <= 6, "one changed row rewrote {delta} rows");
+        assert_eq!(row_names(&db).len(), 20);
+    }
+
+    fn walked_paths(root: &Path, glob: &str) -> Vec<PathBuf> {
+        let matcher = TableMatcher::new(&[(glob, "items")], &[]).unwrap();
+        scanner::scan_subtree(root, root, &matcher)
+            .into_iter()
+            .map(|(path, _)| path)
+            .collect()
+    }
+
+    #[test]
+    fn a_per_table_hook_gets_the_argument_list_a_walk_of_the_tree_gives_it() {
+        let dir = TempDir::new().unwrap();
+        let root = dir.path().canonicalize().unwrap();
+        let write = |rel: &str| {
+            let path = root.join(rel);
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            std::fs::write(&path, "x").unwrap();
+            path
+        };
+        let (items, calls) = recording_per_table("items", "**/*.txt");
+        let db =
+            DirSQL::with_ignore_and_fs(&root, vec![items], Vec::<String>::new(), Arc::new(RealFs))
+                .unwrap();
+        let last_args = || calls.lock().unwrap().last().cloned().unwrap();
+
+        let events: Vec<FileEvent> = [
+            "z.txt",
+            "a-b.txt",
+            "a/c.txt",
+            ".hid.txt",
+            "a/b/d.txt",
+            "n.md",
+        ]
+        .into_iter()
+        .map(|rel| FileEvent::Created(write(rel)))
+        .collect();
+        db.apply_file_events(events);
+        assert_eq!(last_args(), walked_paths(&root, "**/*.txt"));
+
+        write("a/c.txt");
+        db.apply_file_events(vec![FileEvent::Modified(root.join("a/c.txt"))]);
+        assert_eq!(last_args(), walked_paths(&root, "**/*.txt"));
+
+        write("m/one.txt");
+        write("m/deep/two.txt");
+        db.apply_file_events(vec![FileEvent::Created(root.join("m"))]);
+        assert_eq!(last_args(), walked_paths(&root, "**/*.txt"));
+
+        std::fs::remove_file(root.join("a-b.txt")).unwrap();
+        db.apply_file_events(vec![FileEvent::Deleted(root.join("a-b.txt"))]);
+        assert_eq!(last_args(), walked_paths(&root, "**/*.txt"));
+
+        std::fs::remove_dir_all(root.join("m")).unwrap();
+        db.apply_file_events(vec![FileEvent::Deleted(root.join("m"))]);
+        assert_eq!(last_args(), walked_paths(&root, "**/*.txt"));
+    }
+
+    #[test]
+    fn a_vanished_file_is_dropped_from_a_per_table_hooks_arguments() {
+        let dir = TempDir::new().unwrap();
+        let root = dir.path().canonicalize().unwrap();
+        let (items, calls) = recording_per_table("items", "*.txt");
+        let db =
+            DirSQL::with_ignore_and_fs(&root, vec![items], Vec::<String>::new(), Arc::new(RealFs))
+                .unwrap();
+        std::fs::write(root.join("a.txt"), "x").unwrap();
+        db.apply_file_events(vec![FileEvent::Created(root.join("a.txt"))]);
+        std::fs::remove_file(root.join("a.txt")).unwrap();
+
+        db.apply_file_events(vec![FileEvent::Modified(root.join("a.txt"))]);
+
+        assert_eq!(
+            calls.lock().unwrap().last().unwrap(),
+            &Vec::<PathBuf>::new()
+        );
+        assert_eq!(row_names(&db), Vec::<String>::new());
+    }
+
     fn anchored_table(name: &str, glob: &str, anchor: &str) -> Table {
         Table::new(
             name,