dirsql 0.4.105__tar.gz → 0.4.107__tar.gz

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

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

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

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

{dirsql-0.4.105 → dirsql-0.4.107}/docs/howto/react-to-changes.md

@@ -7,7 +7,8 @@ side.
 
 Row events are emitted for **named tables**, so this flow needs a config —
 [path-tables](../reference/path-tables.md) are scanned per query and are not
-watched. Define one next to your files. A named table's columns are whatever
+watched, so `watch()` on an instance with no named tables raises an error and
+`/events` returns `503`. Define one next to your files. A named table's columns are whatever
 its [`on-file`](../reference/config.md#table) hook emits; here a minimal hook
 prints each file's basename:
 

{dirsql-0.4.105/packages/rust → dirsql-0.4.107}/docs/reference/http-api.md

@@ -115,4 +115,4 @@ Row values serialize as in [`POST /query`](#value-serialization).
 |---|---|
 | `200` | Stream opened (`text/event-stream`). |
 | `405` | `POST /events`. Plain-text body `method not allowed`. |
-| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted, or the instance has no named tables). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |

{dirsql-0.4.105 → dirsql-0.4.107}/docs/reference/sdk.md

@@ -301,6 +301,10 @@ under the root. The watcher starts on first iteration (Python/TypeScript)
 or at the `watch()` call (Rust). The stream never terminates on its own;
 stop consuming it to stop.
 
+An instance with no named tables cannot be watched: path-tables emit no
+watch events, so `watch()` (and the polling primitives) raise an error naming
+that cause. Define a table first.
+
 Python/TypeScript: each `watch()` call returns an independent stream, and every stream
 on one instance receives every event observed after it was created, so
 several consumers (one per client, say) can share one instance.

{dirsql-0.4.105 → dirsql-0.4.107}/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.105"
+version = "0.4.107"
 # 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.107/packages/python/changelog.d/2026-10-08-watch-requires-named-table.md

@@ -0,0 +1 @@
+**Changed** — `watch()` (and the polling primitives) on an instance with no named tables now fails immediately with `watching requires at least one named table: path-tables emit no watch events; define a table`, instead of starting a watcher that never yields. The `dirsql server` `/events` endpoint returns 503 with the same reason; `/query` is unaffected.

{dirsql-0.4.105/packages/rust → dirsql-0.4.107/packages/python}/docs/howto/react-to-changes.md

@@ -7,7 +7,8 @@ side.
 
 Row events are emitted for **named tables**, so this flow needs a config —
 [path-tables](../reference/path-tables.md) are scanned per query and are not
-watched. Define one next to your files. A named table's columns are whatever
+watched, so `watch()` on an instance with no named tables raises an error and
+`/events` returns `503`. Define one next to your files. A named table's columns are whatever
 its [`on-file`](../reference/config.md#table) hook emits; here a minimal hook
 prints each file's basename:
 

{dirsql-0.4.105 → dirsql-0.4.107}/packages/python/docs/reference/http-api.md

@@ -115,4 +115,4 @@ Row values serialize as in [`POST /query`](#value-serialization).
 |---|---|
 | `200` | Stream opened (`text/event-stream`). |
 | `405` | `POST /events`. Plain-text body `method not allowed`. |
-| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted, or the instance has no named tables). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |

{dirsql-0.4.105/packages/rust → dirsql-0.4.107/packages/python}/docs/reference/sdk.md

@@ -301,6 +301,10 @@ under the root. The watcher starts on first iteration (Python/TypeScript)
 or at the `watch()` call (Rust). The stream never terminates on its own;
 stop consuming it to stop.
 
+An instance with no named tables cannot be watched: path-tables emit no
+watch events, so `watch()` (and the polling primitives) raise an error naming
+that cause. Define a table first.
+
 Python/TypeScript: each `watch()` call returns an independent stream, and every stream
 on one instance receives every event observed after it was created, so
 several consumers (one per client, say) can share one instance.

dirsql-0.4.107/packages/python/e2e-attestations/bot-1406-watch-no-tables-1008.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/server_speed_test.py tests/e2e/query_contract_test.py tests/e2e/sigint_interrupt_test.py tests/e2e/cli_version_test.py -x -q",
+  "ran_at": 1791474667,
+  "exit_code": 0,
+  "commit": "31f567c6cc0e5873a9bdc41df84e95a6722527f1",
+  "branch": "bot/1406-watch-no-tables-1008"
+}

dirsql-0.4.107/packages/python/e2e-attestations/bot-1459-rescan-on-overflow-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_notebook_test.py -x -q",
+  "ran_at": 1791464863,
+  "exit_code": 0,
+  "commit": "480d3e491818207f55eb2d8dc6c95498dc27afab",
+  "branch": "bot/1459-rescan-on-overflow-1008"
+}

dirsql-0.4.107/packages/python/migrations.d/2026-10-08-watch-requires-named-table.md

@@ -0,0 +1,23 @@
+### `watch()` requires a named table
+
+#### Summary
+
+`watch()`, `poll_events()`/`pollEvents()` and `start_watching()`/`startWatcher()` on an instance with no named tables now raise an error naming the cause, rather than watching and silently yielding nothing. Path-tables emit no watch events. Instances with at least one named table are unaffected.
+
+#### Required changes
+
+| Before | After |
+| --- | --- |
+| `DirSQL(root).watch()` yields nothing forever | Define a table (programmatic or `[[table]]`), or stop calling `watch()` |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+A path-table-only instance that called `watch()` now gets an error. `dirsql server` with no tables returns 503 from `/events`.
+
+#### Verification
+
+Run `dirsql server -c <config with no [[table]]>` and `curl -i http://localhost:7117/events`; expect `503` naming "path-tables emit no watch events".

{dirsql-0.4.105 → dirsql-0.4.107}/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.105"
+version = "0.4.107"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.105/packages/python → dirsql-0.4.107/packages/rust}/docs/howto/react-to-changes.md

@@ -7,7 +7,8 @@ side.
 
 Row events are emitted for **named tables**, so this flow needs a config —
 [path-tables](../reference/path-tables.md) are scanned per query and are not
-watched. Define one next to your files. A named table's columns are whatever
+watched, so `watch()` on an instance with no named tables raises an error and
+`/events` returns `503`. Define one next to your files. A named table's columns are whatever
 its [`on-file`](../reference/config.md#table) hook emits; here a minimal hook
 prints each file's basename:
 

{dirsql-0.4.105 → dirsql-0.4.107/packages/rust}/docs/reference/http-api.md

@@ -115,4 +115,4 @@ Row values serialize as in [`POST /query`](#value-serialization).
 |---|---|
 | `200` | Stream opened (`text/event-stream`). |
 | `405` | `POST /events`. Plain-text body `method not allowed`. |
-| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted, or the instance has no named tables). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |

{dirsql-0.4.105/packages/python → dirsql-0.4.107/packages/rust}/docs/reference/sdk.md

@@ -301,6 +301,10 @@ under the root. The watcher starts on first iteration (Python/TypeScript)
 or at the `watch()` call (Rust). The stream never terminates on its own;
 stop consuming it to stop.
 
+An instance with no named tables cannot be watched: path-tables emit no
+watch events, so `watch()` (and the polling primitives) raise an error naming
+that cause. Define a table first.
+
 Python/TypeScript: each `watch()` call returns an independent stream, and every stream
 on one instance receives every event observed after it was created, so
 several consumers (one per client, say) can share one instance.

{dirsql-0.4.105 → dirsql-0.4.107}/packages/rust/src/cli/server.rs

@@ -109,6 +109,16 @@ fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) -> Option<String>
 mod tests {
     use super::*;
 
+    fn db_with_a_table(root: &std::path::Path) -> DirSQL {
+        let config = root.join("dirsql.toml");
+        std::fs::write(
+            &config,
+            "[[table]]\nname = \"t\"\nddl = \"CREATE TABLE t (x TEXT)\"\nglob = \"*.none\"\non-file = \"true\"\n",
+        )
+        .unwrap();
+        DirSQL::builder().root(root).config(config).build().unwrap()
+    }
+
     // An `Unavailable` state needs no DB/filesystem, so the real bind /
     // graceful-shutdown plumbing runs without standing up an index.
     #[tokio::test]
@@ -130,7 +140,7 @@ mod tests {
     #[tokio::test]
     async fn serve_with_a_ready_db_attaches_the_watcher_then_shuts_down() {
         let dir = tempfile::tempdir().unwrap();
-        let db = DirSQL::new(dir.path(), Vec::new()).unwrap();
+        let db = db_with_a_table(dir.path());
         let config = ServerConfig::bind("127.0.0.1".to_string(), 0);
         let handle = serve(config, db).await.expect("bind on an ephemeral port");
         assert_ne!(handle.local_addr().port(), 0);
@@ -140,17 +150,29 @@ mod tests {
     #[tokio::test]
     async fn start_watch_task_reports_no_failure_once_the_watcher_attaches() {
         let dir = tempfile::tempdir().unwrap();
-        let db = DirSQL::new(dir.path(), Vec::new()).unwrap();
+        let db = db_with_a_table(dir.path());
         let (tx, _) = broadcast::channel::<String>(1);
         assert_eq!(start_watch_task(db, tx), None);
     }
 
+    #[tokio::test]
+    async fn start_watch_task_names_the_cause_without_named_tables() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = DirSQL::new(dir.path(), Vec::new()).unwrap();
+        let (tx, _) = broadcast::channel::<String>(1);
+        let reason = start_watch_task(db, tx).expect("watch() must fail");
+        assert!(
+            reason.contains("path-tables emit no watch events"),
+            "got: {reason}"
+        );
+    }
+
     // `poll_events` locks out `watch`, the one deterministic way to make the
     // watcher refuse to attach without exhausting inotify.
     #[tokio::test]
     async fn start_watch_task_returns_the_reason_when_the_watcher_cannot_attach() {
         let dir = tempfile::tempdir().unwrap();
-        let db = DirSQL::new(dir.path(), Vec::new()).unwrap();
+        let db = db_with_a_table(dir.path());
         db.poll_events(std::time::Duration::ZERO).unwrap();
         let (tx, _) = broadcast::channel::<String>(1);
         let reason = start_watch_task(db, tx).expect("watch() must fail");

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

@@ -991,6 +991,22 @@ impl Db {
             .collect()
     }
 
+    /// Every distinct `(table_name, file_path)` that owns rows, ordered by
+    /// table then path. A per-table hook's rows have no file owner and are
+    /// not listed.
+    pub fn owned_files(&self) -> Result<Vec<(String, String)>> {
+        let mut stmt = self.conn.prepare(
+            "SELECT DISTINCT table_name, file_path FROM ( \
+                SELECT table_name, file_path FROM _dirsql_internal_rows \
+                UNION ALL \
+                SELECT table_name, file_path FROM _dirsql_internal_ranges) \
+             WHERE file_path != '' \
+             ORDER BY table_name, file_path",
+        )?;
+        let rows = stmt.query_map([], |r| Ok((r.get(0)?, r.get(1)?)))?;
+        Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
+    }
+
     /// Every distinct `(table_name, file_path)` whose file sits beneath the
     /// directory `dir`, ordered by table then path.
     pub fn files_under(&self, dir: &str) -> Result<Vec<(String, String)>> {
@@ -2496,6 +2512,42 @@ mod tests {
         assert!(db.files_under("nothing").unwrap().is_empty());
     }
 
+    #[test]
+    fn owned_files_lists_each_file_once_and_skips_the_batch_owner() {
+        let db = Db::new().unwrap();
+        db.create_table("t1", "CREATE TABLE t1 (id TEXT)").unwrap();
+        db.create_table("t2", "CREATE TABLE t2 (id TEXT)").unwrap();
+        let row = HashMap::from([("id".into(), Value::Text("x".into()))]);
+        for (table, file, idx) in [
+            ("t2", "c.jsonl", 0),
+            ("t1", "a.jsonl", 0),
+            ("t1", "a.jsonl", 1),
+            ("t1", "d/b.jsonl", 0),
+            ("t1", "", 0),
+        ] {
+            db.insert_row(table, &row, file, idx).unwrap();
+        }
+
+        assert_eq!(
+            db.owned_files().unwrap(),
+            vec![
+                ("t1".to_string(), "a.jsonl".to_string()),
+                ("t1".to_string(), "d/b.jsonl".to_string()),
+                ("t2".to_string(), "c.jsonl".to_string()),
+            ]
+        );
+    }
+
+    #[test]
+    fn owned_files_surfaces_sql_failure() {
+        let db = Db::new().unwrap();
+        db.conn
+            .execute("DROP TABLE _dirsql_internal_rows", [])
+            .unwrap();
+        let err = db.owned_files().unwrap_err();
+        assert!(matches!(err, DbError::Sqlite(_)), "got: {err:?}");
+    }
+
     #[test]
     fn files_under_surfaces_sql_failure() {
         let db = Db::new().unwrap();