dirsql 0.3.124__tar.gz → 0.3.126__tar.gz

{dirsql-0.3.124 → dirsql-0.3.126}/Cargo.lock

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

{dirsql-0.3.124 → dirsql-0.3.126}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.124
+Version: 0.3.126
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

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

dirsql-0.3.126/packages/python/changelog.d/2026-07-24-hookless-table-config-error.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **A `[[table]]` with no `on-file` hook is now a config-load error.** After the stat-fact injection layer was removed, a hook-less named table emitted no columns of its own, so every row was all-NULL. Loading such a config (`DirSQL(config=…)` / `.ready()`) now raises, with a message pointing at the fix: add an `on-file` hook that emits the columns, or, for stat columns with no code, query the path directly with a path-table (`FROM './'`). This completes the fact-removal epic (#624). (#634)

dirsql-0.3.126/packages/python/changelog.d/2026-07-24-remove-stat-fact-injection.md

@@ -0,0 +1,3 @@
+**Removed**
+
+- **Removed the stat-fact injection layer** (core change, surfaced through the Python SDK). dirsql no longer auto-fills DDL columns named `path`/`basename`/`dir`/`ext`/`size`/`mtime`/`ctime` from filesystem stat. A `Table` now contains exactly what its `on_file` callback returns; a DDL column the callback never emits is `None`/`NULL`, not injected. To keep a stat column populated, emit it from the callback (e.g. derive `path` from the file argument), or query the path directly with a path-table (`FROM './'`). (#634)

dirsql-0.3.126/packages/python/e2e-attestations/feat-634-slice4-hookless-error.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1784908753,
+  "exit_code": 0,
+  "commit": "f07fcf90987684b0edc4fd44f57f5003d329bd74",
+  "branch": "feat/634-slice4-hookless-error"
+}

dirsql-0.3.126/packages/python/migrations.d/2026-07-24-hookless-table-config-error.md

@@ -0,0 +1,51 @@
+### Hook-less `[[table]]` is now a config error (#634)
+
+#### Summary
+
+A `[[table]]` with no `on-file` hook previously loaded fine and — after the
+stat-fact injection layer was removed — produced rows that were all-NULL.
+Loading such a config through the Python SDK (`DirSQL(config=…)`, awaited via
+`.ready()`) now raises. No API signature changes — this is a load-time
+validation change surfaced from the core.
+
+#### Required changes
+
+| Before (loaded, all-NULL rows) | After (raises) | Fix |
+| ------------------------------ | -------------- | --- |
+| `.dirsql.toml` `[[table]]` with `ddl` + `glob` but no `on-file` | `.ready()` raises `[[table]] '<glob>' has no on-file hook …` | Add an `on-file` hook that emits the declared columns. |
+| You only wanted stat columns and wrote no hook code | `.ready()` raises | Drop the `[[table]]` and query the path directly: `SELECT path, size, mtime FROM './'` (globbable: `FROM './**/*.md'`). |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A `[[table]]` with no `on-file` hook, which used to load (and, after injection
+  removal, yield all-NULL rows), now raises at config load, with an error naming
+  the offending glob and pointing at the `FROM './'` path-table replacement.
+
+#### Verification
+
+```python
+import asyncio
+from dirsql import DirSQL
+
+# .dirsql.toml with a hook-less table:
+#   [[table]]
+#   ddl  = "CREATE TABLE files (path TEXT, size INTEGER)"
+#   glob = "**/*.md"
+
+db = DirSQL(config=".dirsql.toml")
+# Before this change: await db.ready() succeeded; SELECT * FROM files -> all-NULL rows.
+# After this change:
+try:
+    asyncio.run(db.ready())
+except Exception as e:
+    print(e)  # -> ... has no on-file hook ... query the path directly: `FROM './'`
+
+# Replacement with no hook code — query the path directly (no config):
+db2 = DirSQL(root=".")
+asyncio.run(db2.ready())
+print(asyncio.run(db2.query("SELECT path, size FROM './**/*.md'")))
+```

dirsql-0.3.126/packages/python/migrations.d/2026-07-24-remove-stat-fact-injection.md

@@ -0,0 +1,51 @@
+### Stat-fact injection removed (#634)
+
+#### Summary
+
+dirsql previously injected filesystem-derived values into any DDL column named
+`path`, `basename`, `dir`, `ext`, `size`, `mtime`, or `ctime` — filling them
+even when a table's `on_file` callback emitted nothing for that column. That
+injection layer (in the shared Rust core) is gone. A `Table` now contains
+**exactly what its `on_file` callback returns**; a declared column the callback
+never emits is `None`/`NULL`. No Python API signature changes — runtime
+behavior only.
+
+#### Required changes
+
+| Before (injected) | After (NULL unless emitted) | Fix |
+| ----------------- | --------------------------- | --- |
+| DDL declares `path TEXT`, callback omits it → column held the root-relative path | Column is `None` | Emit it from the callback: `Table("CREATE TABLE t (path TEXT)", "**/*", on_file=lambda path: [{"path": path}])`. |
+| DDL declares `size INTEGER`, callback omits it → column held the file size | Column is `None` | Emit it: `on_file=lambda path: [{"size": os.path.getsize(path)}]`. |
+| Want stat columns with **no** callback at all | (was injection) | Query the path directly with a path-table: `FROM './'`. |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A DDL column named `path`/`basename`/`dir`/`ext`/`size`/`mtime`/`ctime` that
+  the `on_file` callback does not emit is now `None`/`NULL` instead of an
+  injected filesystem value.
+- A **strict** table whose DDL declares such a column but whose callback does
+  not emit it now raises a schema-validation error rather than being silently
+  filled.
+
+#### Verification
+
+```python
+from dirsql import DirSQL, Table
+
+# Callback emits only "size"; DDL also declares "path".
+db = DirSQL(root, tables=[Table(
+    ddl="CREATE TABLE files (path TEXT, size INTEGER)",
+    glob="**/*.txt",
+    on_file=lambda _path: [{"size": 42}],
+)])
+rows = db.query("SELECT path, size FROM files")
+# Before: rows[0]["path"] == "a.txt"  (injected)
+# After:  rows[0]["path"] is None      (not emitted)
+
+# Restore by emitting it:
+#   on_file=lambda path: [{"path": path, "size": 42}]
+```

dirsql-0.3.126/packages/rust/changelog.d/2026-07-24-hookless-table-config-error.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **A `[[table]]` with no `on-file` hook is now a load error.** After the stat-fact injection layer was removed, a hook-less named table emitted no columns of its own, so every row was all-NULL — useless and surprising. `load_config_str` (and every path that loads a config, including `DirSQL::from_config_path` and the CLI's `-c`) now rejects such a table with a message pointing at the fix: add an `on-file` hook that emits the columns, or, for stat columns with no code, query the path directly with a path-table (`FROM './'`). This completes the fact-removal epic (#624). (#634)

dirsql-0.3.126/packages/rust/changelog.d/2026-07-24-remove-stat-fact-injection.md

@@ -0,0 +1,3 @@
+**Removed**
+
+- **Removed the stat-fact injection layer.** dirsql no longer auto-fills DDL columns named `path`/`basename`/`dir`/`ext`/`size`/`mtime`/`ctime` from filesystem stat. A named table now contains exactly what its `on-file` hook emits; a DDL column the hook never emits is `NULL` (standard SQL), not injected. To keep a stat column populated, emit it from the hook (e.g. derive `path` from the file argument), or query the path directly with a path-table (`FROM './'`). (#634)

dirsql-0.3.126/packages/rust/migrations.d/2026-07-24-hookless-table-config-error.md

@@ -0,0 +1,51 @@
+### Hook-less `[[table]]` is now a config error (#634)
+
+#### Summary
+
+A `[[table]]` (or SDK-registered table) with no `on-file` hook previously
+loaded fine and — after the stat-fact injection layer was removed — produced
+rows that were all-NULL. dirsql now rejects a hook-less table at config load
+(`ConfigError::HooklessTable`), so the failure is loud and actionable instead
+of a silently useless table. No API signature changes — this is a
+load-time validation change. `TableConfig.on_file` is now `String` (was
+`Option<String>`) since a parsed table always carries a hook.
+
+#### Required changes
+
+| Before (loaded, all-NULL rows) | After (load error) | Fix |
+| ------------------------------ | ------------------ | --- |
+| `[[table]]` declares `ddl` + `glob` but no `on-file` | Load fails: `[[table]] '<glob>' has no on-file hook …` | Add an `on-file` hook that emits the declared columns, e.g. `on-file = 'rel=${1#"$2"/}; jq -n --arg path "$rel" '\''[{path:$path}]'\'''`. |
+| You only wanted stat columns and wrote no hook code | Load fails | Drop the `[[table]]` and query the path directly with a path-table: `SELECT path, size, mtime FROM './'` (globbable: `FROM './**/*.md'`). |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A `[[table]]` with no `on-file` hook, which used to load (and, after injection
+  removal, yield all-NULL rows), now fails at config load with an error naming
+  the offending glob and pointing at the `FROM './'` path-table replacement.
+
+#### Verification
+
+```bash
+# .dirsql.toml with a hook-less table:
+#   [[table]]
+#   ddl  = "CREATE TABLE files (path TEXT, size INTEGER)"
+#   glob = "**/*.md"
+
+# Before this change:
+dirsql query "SELECT * FROM files" -c ./.dirsql.toml
+# -> [] or all-NULL rows (loaded, but useless)
+
+# After this change:
+dirsql query "SELECT * FROM files" -c ./.dirsql.toml
+# -> error: [[table]] '**/*.md' has no on-file hook, so every row would be
+#    all-NULL. Add an `on-file` hook that emits the columns, or, for stat
+#    columns with no code, query the path directly: `FROM './'`
+
+# Replacement with no hook code — query the path directly:
+dirsql query "SELECT path, size FROM './**/*.md'"
+# -> rows with real path/size, no config needed
+```

dirsql-0.3.126/packages/rust/migrations.d/2026-07-24-remove-stat-fact-injection.md

@@ -0,0 +1,55 @@
+### Stat-fact injection removed (#634)
+
+#### Summary
+
+dirsql previously injected filesystem-derived values into any DDL column named
+`path`, `basename`, `dir`, `ext`, `size`, `mtime`, or `ctime` — filling them
+even when the `on-file` hook emitted nothing for that column. That injection
+layer is gone. A named table now contains **exactly what its hook emits**; a
+declared column the hook never emits is `NULL` (standard SQL). No API signature
+changes — this is a runtime behavior change.
+
+#### Required changes
+
+| Before (injected) | After (NULL unless emitted) | Fix |
+| ----------------- | --------------------------- | --- |
+| DDL declares `path TEXT`, hook emits neither `path` nor a value for it → column held the root-relative path | Column is `NULL` | Emit it from the hook. Config `on-file` shell hook (`$1` = abs path, `$2` = index root): `rel=${1#"$2"/}; jq -n --arg path "$rel" '[{path:$path}]'`. Rust SDK closure: `\|path\| vec![HashMap::from([("path".into(), Value::Text(path.to_string()))])]`. |
+| DDL declares `size INTEGER`, hook emits neither → column held the file size | Column is `NULL` | Emit it from the hook: `jq -n --argjson size "$(stat -c%s "$1")" '[{size:$size}]'`, or in Rust read `std::fs::metadata(path)?.len()`. |
+| Want stat columns with **no** hook code at all | (was injection) | Query the path directly with a path-table: `FROM './'`. |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A DDL column named `path`/`basename`/`dir`/`ext`/`size`/`mtime`/`ctime` that
+  the `on-file` hook does not emit is now `NULL` instead of an injected
+  filesystem value. Configs and SDK tables that relied on injection must emit
+  the column themselves (see the table above).
+- A **strict** table whose DDL declares such a column but whose hook does not
+  emit it now fails schema validation (`missing columns for table …`) rather
+  than being silently filled.
+
+#### Verification
+
+Given `a.txt` in the index root and a non-strict table whose DDL is
+`CREATE TABLE files (path TEXT, size INTEGER)` and whose hook emits only
+`size`:
+
+```bash
+# Config flags follow the subcommand: `dirsql query <sql> -c <cfg>`.
+
+# Before this change (hook emits only size):
+dirsql query "SELECT path, size FROM files" -c ./.dirsql.toml
+# -> [{"path":"a.txt","size":42}]   (path injected)
+
+# After this change (same config):
+dirsql query "SELECT path, size FROM files" -c ./.dirsql.toml
+# -> [{"path":null,"size":42}]      (path NULL — not emitted)
+
+# Restore it by emitting path from the hook:
+#   on-file = 'rel=${1#"$2"/}; jq -n --arg path "$rel" '\''[{path:$path}]'\'''
+dirsql query "SELECT path, size FROM files" -c ./.dirsql.toml
+# -> [{"path":"a.txt", ...}]        (path populated again)
+```

{dirsql-0.3.124 → dirsql-0.3.126}/packages/rust/src/config.rs

@@ -21,6 +21,13 @@ pub enum ConfigError {
     #[error("Field '{0}' must not be empty")]
     EmptyField(&'static str),
 
+    #[error(
+        "[[table]] '{glob}' has no on-file hook, so every row would be all-NULL. \
+         Add an `on-file` hook that emits the columns, or, for stat columns with \
+         no code, query the path directly: `FROM './'`"
+    )]
+    HooklessTable { glob: String },
+
     #[error("Field '{field}' must be a positive number of seconds, got {value}")]
     InvalidTimeout { field: &'static str, value: i64 },
 
@@ -221,11 +228,12 @@ pub struct TableConfig {
     pub ddl: String,
     pub glob: String,
     pub strict: Option<bool>,
-    /// Optional per-file command (`on-file`). When set, each matched file's
-    /// rows come from running this command (which reads the file and prints a
-    /// JSON array of row objects) instead of the empty filesystem-facts-only
-    /// row. See `dirsql::command` for the execution contract.
-    pub on_file: Option<String>,
+    /// The required per-file command (`on-file`). Each matched file's rows come
+    /// from running this command, which reads the file and prints a JSON array
+    /// of row objects. A table without it would emit no columns of its own —
+    /// every row all-NULL — so it is rejected at load. See `dirsql::command`
+    /// for the execution contract.
+    pub on_file: String,
 }
 
 #[derive(Deserialize)]
@@ -323,7 +331,8 @@ pub fn load_config_str(content: &str) -> Result<Config> {
             Some(cmd) if cmd.trim().is_empty() => {
                 return Err(ConfigError::EmptyField("on-file"));
             }
-            other => other,
+            Some(cmd) => cmd,
+            None => return Err(ConfigError::HooklessTable { glob }),
         };
 
         tables.push(TableConfig {
@@ -367,10 +376,12 @@ ignore = ["node_modules/**", ".git/**"]
 [[table]]
 ddl = "CREATE TABLE comments (thread_id TEXT, path TEXT)"
 glob = "_comments/{thread_id}/index.jsonl"
+on-file = "cat {path}"
 
 [[table]]
 ddl = "CREATE TABLE items (path TEXT, size INTEGER)"
 glob = "catalog/*.json"
+on-file = "cat {path}"
 strict = true
 "#;
         let config = load_config_str(toml).unwrap();
@@ -391,6 +402,7 @@ strict = true
         let toml = r#"
 [[table]]
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let err = load_config_str(toml).unwrap_err();
         assert!(err.to_string().contains("ddl"));
@@ -438,6 +450,7 @@ ignore = ["*.tmp"]
 [[table]]
 ddl = "CREATE TABLE t (x TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert!(config.ignore.is_empty());
@@ -478,14 +491,17 @@ persist_path = "/var/cache/dirsql.db"
 [[table]]
 ddl = "CREATE TABLE a (path TEXT)"
 glob = "a/*.json"
+on-file = "cat {path}"
 
 [[table]]
 ddl = "CREATE TABLE b (path TEXT)"
 glob = "b/*.csv"
+on-file = "cat {path}"
 
 [[table]]
 ddl = "CREATE TABLE c (path TEXT)"
 glob = "c/*.yaml"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert_eq!(config.tables.len(), 3);
@@ -502,6 +518,7 @@ glob = "c/*.yaml"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 format = "json"
 "#;
         let err = load_config_str(toml).unwrap_err();
@@ -568,6 +585,7 @@ entrypoint = "sqlite3_vec_init"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert_eq!(config.extensions.len(), 1);
@@ -608,6 +626,7 @@ entrypoint = "sqlite3_x_init"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert!(config.extensions.is_empty());
@@ -639,20 +658,26 @@ on-file = "uv run python extract_papers.py {path}"
         let config = load_config_str(toml).unwrap();
         assert_eq!(config.tables.len(), 1);
         assert_eq!(
-            config.tables[0].on_file.as_deref(),
-            Some("uv run python extract_papers.py {path}")
+            config.tables[0].on_file,
+            "uv run python extract_papers.py {path}"
         );
     }
 
     #[test]
-    fn on_file_absent_is_none() {
+    fn on_file_absent_is_a_hookless_load_error() {
         let toml = r#"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
 "#;
-        let config = load_config_str(toml).unwrap();
-        assert!(config.tables[0].on_file.is_none());
+        let err = load_config_str(toml).unwrap_err();
+        assert!(
+            matches!(&err, ConfigError::HooklessTable { glob } if glob == "*.json"),
+            "got: {err:?}"
+        );
+        let msg = err.to_string();
+        assert!(msg.contains("on-file"), "got: {msg}");
+        assert!(msg.contains("FROM './'"), "got: {msg}");
     }
 
     #[test]
@@ -679,6 +704,7 @@ pre-query = "uv run python to_sql.py {args}"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert_eq!(
@@ -693,6 +719,7 @@ glob = "*.json"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert!(config.pre_query.is_none());
@@ -720,6 +747,7 @@ post-query = "jq '{results: .}'"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert_eq!(config.post_query.as_deref(), Some("jq '{results: .}'"));
@@ -731,6 +759,7 @@ glob = "*.json"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert!(config.post_query.is_none());
@@ -778,6 +807,7 @@ entrypoint = "sqlite3_vec_init"
 [[table]]
 ddl = "CREATE TABLE t (path TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#);
         let merged = combine_configs(&[(src("/proj/.dirsql.toml"), config.clone())]).unwrap();
         assert_eq!(merged.ignore, config.ignore);
@@ -795,15 +825,18 @@ glob = "*.json"
 [[table]]
 ddl = "CREATE TABLE a (path TEXT)"
 glob = "a/*.json"
+on-file = "cat {path}"
 
 [[table]]
 ddl = "CREATE TABLE b (path TEXT)"
 glob = "b/*.json"
+on-file = "cat {path}"
 "#);
         let b = cfg(r#"
 [[table]]
 ddl = "CREATE TABLE c (path TEXT)"
 glob = "c/*.json"
+on-file = "cat {path}"
 "#);
         let merged = combine_configs(&[(src("/a"), a), (src("/b"), b)]).unwrap();
         let ddls: Vec<&str> = merged.tables.iter().map(|t| t.ddl.as_str()).collect();
@@ -848,8 +881,12 @@ glob = "c/*.json"
 
     #[test]
     fn combine_duplicate_table_name_errors_naming_both_sources() {
-        let a = cfg("[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\n");
-        let b = cfg("[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\n");
+        let a = cfg(
+            "[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\non-file = \"cat {path}\"\n",
+        );
+        let b = cfg(
+            "[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\non-file = \"cat {path}\"\n",
+        );
         let err = combine_configs(&[
             (src("/proj/.dirsql.toml"), a),
             (src("/plugin/frag.toml"), b),
@@ -878,8 +915,8 @@ glob = "c/*.json"
         // The single-entry identity path runs no collision check, exactly like
         // a plain single-config load.
         let config = cfg(concat!(
-            "[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\n",
-            "[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\n",
+            "[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\non-file = \"cat {path}\"\n",
+            "[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\non-file = \"cat {path}\"\n",
         ));
         let merged = combine_configs(&[(src("/a"), config)]).unwrap();
         assert_eq!(merged.tables.len(), 2);
@@ -888,8 +925,8 @@ glob = "c/*.json"
     #[test]
     fn combine_intra_config_duplicate_in_multi_merge_errors() {
         let a = cfg(concat!(
-            "[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\n",
-            "[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\n",
+            "[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\non-file = \"cat {path}\"\n",
+            "[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\non-file = \"cat {path}\"\n",
         ));
         let b = cfg("[dirsql]\nignore = [\"c/**\"]\n");
         let err = combine_configs(&[(src("/a"), a), (src("/b"), b)]).unwrap_err();
@@ -909,8 +946,12 @@ glob = "c/*.json"
 
     #[test]
     fn combine_duplicate_table_name_detected_through_quoting() {
-        let a = cfg("[[table]]\nddl = 'CREATE TABLE \"t\" (x TEXT)'\nglob = \"a/*.json\"\n");
-        let b = cfg("[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\n");
+        let a = cfg(
+            "[[table]]\nddl = 'CREATE TABLE \"t\" (x TEXT)'\nglob = \"a/*.json\"\non-file = \"cat {path}\"\n",
+        );
+        let b = cfg(
+            "[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\non-file = \"cat {path}\"\n",
+        );
         let err = combine_configs(&[(src("/a"), a), (src("/b"), b)]).unwrap_err();
         assert!(
             matches!(&err, ConfigError::DuplicateTable { name, .. } if name == "t"),
@@ -920,8 +961,12 @@ glob = "c/*.json"
 
     #[test]
     fn combine_unparseable_ddl_concatenates_without_collision_check() {
-        let a = cfg("[[table]]\nddl = \"not a create table\"\nglob = \"a/*.json\"\n");
-        let b = cfg("[[table]]\nddl = \"also not a create table\"\nglob = \"b/*.json\"\n");
+        let a = cfg(
+            "[[table]]\nddl = \"not a create table\"\nglob = \"a/*.json\"\non-file = \"cat {path}\"\n",
+        );
+        let b = cfg(
+            "[[table]]\nddl = \"also not a create table\"\nglob = \"b/*.json\"\non-file = \"cat {path}\"\n",
+        );
         let merged = combine_configs(&[(src("/a"), a), (src("/b"), b)]).unwrap();
         assert_eq!(merged.tables.len(), 2);
     }
@@ -967,8 +1012,12 @@ glob = "c/*.json"
 
     #[test]
     fn combine_error_display_includes_package_source_verbatim() {
-        let a = cfg("[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\n");
-        let b = cfg("[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\n");
+        let a = cfg(
+            "[[table]]\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"a/*.json\"\non-file = \"cat {path}\"\n",
+        );
+        let b = cfg(
+            "[[table]]\nddl = \"CREATE TABLE t (y TEXT)\"\nglob = \"b/*.json\"\non-file = \"cat {path}\"\n",
+        );
         let err = combine_configs(&[
             (src("/proj/.dirsql.toml"), a),
             (Source::Package("dirsql-plugin-notes".to_string()), b),
@@ -982,11 +1031,13 @@ glob = "c/*.json"
     #[test]
     fn combine_three_configs_concatenates_across_all() {
         let a = cfg(
-            "[dirsql]\nignore = [\"a/**\"]\n\n[[table]]\nddl = \"CREATE TABLE a (x TEXT)\"\nglob = \"a/*\"\n",
+            "[dirsql]\nignore = [\"a/**\"]\n\n[[table]]\nddl = \"CREATE TABLE a (x TEXT)\"\nglob = \"a/*\"\non-file = \"cat {path}\"\n",
+        );
+        let b = cfg(
+            "[[table]]\nddl = \"CREATE TABLE b (x TEXT)\"\nglob = \"b/*\"\non-file = \"cat {path}\"\n",
         );
-        let b = cfg("[[table]]\nddl = \"CREATE TABLE b (x TEXT)\"\nglob = \"b/*\"\n");
         let c = cfg(
-            "[dirsql]\nignore = [\"c/**\"]\n\n[[table]]\nddl = \"CREATE TABLE c (x TEXT)\"\nglob = \"c/*\"\n",
+            "[dirsql]\nignore = [\"c/**\"]\n\n[[table]]\nddl = \"CREATE TABLE c (x TEXT)\"\nglob = \"c/*\"\non-file = \"cat {path}\"\n",
         );
         let merged = combine_configs(&[(src("/a"), a), (src("/b"), b), (src("/c"), c)]).unwrap();
         assert_eq!(merged.ignore, vec!["a/**", "c/**"]);
@@ -1026,6 +1077,7 @@ hook-timeout = 300
 [[table]]
 ddl = "CREATE TABLE t (x TEXT)"
 glob = "*.json"
+on-file = "cat {path}"
 "#;
         let config = load_config_str(toml).unwrap();
         assert!(config.hook_timeout.is_none());