dirsql 0.4.84__tar.gz → 0.4.85__tar.gz

{dirsql-0.4.84 → dirsql-0.4.85}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.84"
+version = "0.4.85"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -602,7 +602,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.84"
+version = "0.4.85"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.84 → dirsql-0.4.85}/PKG-INFO

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

{dirsql-0.4.84/packages/rust → dirsql-0.4.85}/docs/reference/http-api.md

@@ -112,4 +112,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). JSON `{"error": …}` body. |
+| `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. |

{dirsql-0.4.84 → dirsql-0.4.85}/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.84"
+version = "0.4.85"
 # 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.85/packages/python/changelog.d/2026-10-06-one-glob-compiler.md

@@ -0,0 +1,3 @@
+**Changed** A declared `[[table]] glob` is compiled by the same glob compiler
+as a path-table, so brace ranges such as `f{1..3}.md` and the other bash brace
+rules now read the same on both surfaces.

{dirsql-0.4.84 → dirsql-0.4.85}/packages/python/docs/reference/http-api.md

@@ -112,4 +112,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). JSON `{"error": …}` body. |
+| `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. |

dirsql-0.4.85/packages/python/e2e-attestations/bot-1398-inotify-error.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/cli_version_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791309015,
+  "exit_code": 0,
+  "commit": "d60aff48881ae3201bccd0e6e77f52e6cd62c646",
+  "branch": "bot/1398-inotify-error"
+}

dirsql-0.4.85/packages/python/e2e-attestations/bot-1407-child-place-depth.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/fanout_test.py -x -q",
+  "ran_at": 1791310157,
+  "exit_code": 0,
+  "commit": "7104e6400efd6f912a92a53dd0d8f6d4c6c3a947",
+  "branch": "bot/1407-child-place-depth"
+}

dirsql-0.4.85/packages/python/e2e-attestations/claude-1258-one-pattern.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/capture_collision_test.py tests/e2e/declared_table_name_test.py tests/e2e/extension_package_test.py tests/e2e/query_contract_test.py tests/e2e/plugin_discovery_test.py tests/e2e/sigint_interrupt_test.py tests/e2e/fanout_test.py tests/e2e/use_case_transcripts_test.py tests/e2e/plugin_extension_discovery_test.py -x -q",
+  "ran_at": 1791301900,
+  "exit_code": 0,
+  "commit": "14d2a11edd69bb0715bbffdb085b1d6582728dd8",
+  "branch": "claude/1258-one-pattern"
+}

dirsql-0.4.85/packages/python/e2e-attestations/claude-1330-vtab-prefetch-flag.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/query_contract_test.py tests/e2e/declared_table_name_test.py tests/e2e/fanout_test.py -x -q",
+  "ran_at": 1791310416,
+  "exit_code": 0,
+  "commit": "bcedde49401cf6f9cc01deb2d95af1d1e907f0f7",
+  "branch": "claude/1330-vtab-prefetch-flag"
+}

dirsql-0.4.85/packages/python/migrations.d/2026-10-06-one-glob-compiler.md

@@ -0,0 +1,28 @@
+### Config table globs share the path-table glob compiler
+
+#### Summary
+
+A declared `[[table]] glob` is now compiled by the same compiler as a
+path-table. A brace range such as `f{1..3}.md` expands as in bash instead of
+matching nothing. Nothing else changes.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- `glob = "f{1..3}.md"` matches `f1.md`, `f2.md` and `f3.md`.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+touch f1.md f2.md f3.md f4.md
+dirsql query "SELECT path FROM './f{1..3}.md' ORDER BY path"
+# expected: [{"path":"f1.md"},{"path":"f2.md"},{"path":"f3.md"}]
+```

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

{dirsql-0.4.84 → dirsql-0.4.85/packages/rust}/docs/reference/http-api.md

@@ -112,4 +112,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). JSON `{"error": …}` body. |
+| `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. |

{dirsql-0.4.84 → dirsql-0.4.85}/packages/rust/src/cli/router.rs

@@ -26,6 +26,7 @@ use super::execute::{QueryFailure, execute_query, require_ready};
 pub(super) struct AppContext {
     pub state: AppState,
     pub events: broadcast::Sender<String>,
+    pub watch_failure: Option<String>,
     pub cancel: watch::Receiver<bool>,
     pub query_timeout: Duration,
 }
@@ -72,6 +73,9 @@ async fn handle_events(State(ctx): State<SharedCtx>) -> Response {
     if let Err(failure) = require_ready(&ctx.state) {
         return failure_response(&failure);
     }
+    if let Some(reason) = &ctx.watch_failure {
+        return failure_response(&QueryFailure::Unavailable(reason.clone()));
+    }
 
     // Subscribe BEFORE anything that might block so we don't drop events
     // that fire between subscribing and the first poll.
@@ -163,6 +167,21 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn events_return_503_while_the_server_is_unavailable() {
+        let (events, _) = broadcast::channel::<String>(1);
+        let (_cancel_tx, cancel) = watch::channel(false);
+        let ctx = Arc::new(AppContext {
+            state: AppState::Unavailable("config failed to load".into()),
+            events,
+            watch_failure: None,
+            cancel,
+            query_timeout: Duration::from_secs(1),
+        });
+        let resp = handle_events(State(ctx)).await;
+        assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
+    }
+
     #[test]
     fn error_response_sets_json_content_type() {
         let resp = error_response(StatusCode::BAD_REQUEST, "boom");

{dirsql-0.4.84 → dirsql-0.4.85}/packages/rust/src/cli/server.rs

@@ -38,14 +38,16 @@ pub async fn serve_with_state(
     // the underlying notify watcher (which `DirSQL::watch` only permits
     // once per instance).
     let (event_tx, _) = broadcast::channel::<String>(256);
-    if let AppState::Ready(ref db) = state {
-        start_watch_task(db.clone(), event_tx.clone());
-    }
+    let watch_failure = match state {
+        AppState::Ready(ref db) => start_watch_task(db.clone(), event_tx.clone()),
+        AppState::Unavailable(_) => None,
+    };
 
     let (cancel_tx, cancel_rx) = watch::channel(false);
     let shared = Arc::new(AppContext {
         state,
         events: event_tx,
+        watch_failure,
         cancel: cancel_rx,
         query_timeout: config.query_timeout,
     });
@@ -69,18 +71,20 @@ pub async fn serve_with_state(
     })
 }
 
-fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) {
+/// Returns the reason `/events` must refuse requests when the watcher
+/// could not attach.
+fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) -> Option<String> {
     // `db.watch()` spawns its own OS thread and returns an async stream.
     // We pump the stream into the broadcast channel. If no subscribers
     // exist, send() errors but we keep pumping (future subscribers
     // will get subsequent events).
-    let Ok(mut stream) = db.watch().map_err(|err| {
-        eprintln!(
-            "dirsql: failed to attach filesystem watcher ({err}); \
-             /events will return an empty stream"
-        );
-    }) else {
-        return;
+    let mut stream = match db.watch() {
+        Ok(stream) => stream,
+        Err(err) => {
+            let reason = format!("filesystem watcher failed to start: {err}");
+            eprintln!("dirsql: {reason}; /events will return 503");
+            return Some(reason);
+        }
     };
     tokio::spawn(async move {
         while let Some(event) = stream.next().await {
@@ -88,6 +92,7 @@ fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) {
             let _ = tx.send(payload);
         }
     });
+    None
 }
 
 #[cfg(test)]
@@ -122,6 +127,29 @@ mod tests {
         handle.shutdown().await.expect("graceful shutdown");
     }
 
+    #[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 (tx, _) = broadcast::channel::<String>(1);
+        assert_eq!(start_watch_task(db, tx), None);
+    }
+
+    // `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();
+        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");
+        assert!(
+            reason.starts_with("filesystem watcher failed to start: "),
+            "got: {reason}"
+        );
+    }
+
     // Binding to a non-local TEST-NET address (RFC 5737) fails with
     // "cannot assign requested address", surfacing `ServerError::Bind` rather
     // than panicking — deterministic and DNS-free.

{dirsql-0.4.84 → dirsql-0.4.85}/packages/rust/src/lib.rs

@@ -224,9 +224,9 @@ impl DirSqlError {
         DirSqlError::Lock(e.to_string())
     }
 
-    fn watch<E: StdError + Send + Sync + 'static>(e: E) -> Self {
+    fn watch(e: notify::Error) -> Self {
         DirSqlError::Watch {
-            message: e.to_string(),
+            message: watcher::describe_watch_error(&e, cfg!(target_os = "linux")),
             source: Some(Box::new(e)),
         }
     }
@@ -2527,6 +2527,11 @@ struct AsyncDirSqlInner {
     ready_notify: tokio::sync::Notify,
 }
 
+#[cfg(test)]
+fn generic_watch_error(message: &str) -> notify::Error {
+    notify::Error::generic(message)
+}
+
 #[cfg(test)]
 impl AsyncDirSqlInner {
     /// Fresh inner with an empty `db` cell — the pre-`ready` state.
@@ -2681,10 +2686,10 @@ mod readonly_tests {
             DirSqlError::lock("x").to_string(),
             "failed to lock shared state: x"
         );
-        // `watch`, `config`, `matcher` wrap a typed StdError to preserve a
+        // `watch`, `config`, `matcher` wrap a typed error to preserve a
         // `source()` chain.
         let io = || std::io::Error::other("x");
-        let watch_err = DirSqlError::watch(io());
+        let watch_err = DirSqlError::watch(generic_watch_error("x"));
         assert_eq!(watch_err.to_string(), "watcher error: x");
         assert!(StdError::source(&watch_err).is_some());
 

{dirsql-0.4.84 → dirsql-0.4.85}/packages/rust/src/matcher.rs

@@ -1,4 +1,5 @@
 use crate::posix_class::expand_posix_classes;
+use crate::scanner::{PathGlob, compile_glob};
 use globset::GlobBuilder;
 use regex::{Regex, RegexBuilder};
 use std::path::Path;
@@ -81,7 +82,7 @@ pub struct MatchResult {
 /// A compiled glob pattern. `{name}` placeholders are rewritten to `*` before
 /// compilation, so they are pure match wildcards.
 struct PatternEntry {
-    pattern: Pattern,
+    pattern: PathGlob,
     table_name: String,
 }
 
@@ -161,7 +162,7 @@ impl TableMatcher {
         let mut entries = Vec::new();
         for (pattern, table_name) in mappings {
             entries.push(PatternEntry {
-                pattern: Pattern::new(&glob_with_placeholders_as_star(pattern))?,
+                pattern: compile_glob(&glob_with_placeholders_as_star(pattern))?,
                 table_name: table_name.to_string(),
             });
         }

{dirsql-0.4.84 → dirsql-0.4.85}/packages/rust/src/scanner.rs

@@ -921,6 +921,35 @@ mod tests {
         );
     }
 
+    fn explored_dirs(place: Place<'_>) -> Vec<Place<'_>> {
+        place
+            .explore(&|_| true)
+            .into_iter()
+            .filter_map(|step| match step {
+                Step::Dir(child) => Some(*child),
+                Step::Leaf(_) => None,
+            })
+            .collect()
+    }
+
+    #[test]
+    fn explore_enters_a_dirsql_directory_below_the_top_level() {
+        let root = tempfile::tempdir().unwrap();
+        fs::create_dir_all(root.path().join("a").join(RESERVED_DIR)).unwrap();
+        let ignore = TableMatcher::new(&[], &[]).unwrap();
+        let top = Place {
+            walk: walk_with(&ignore, None, Vec::new()),
+            dir: root.path().to_path_buf(),
+            rel: PathBuf::new(),
+            depth: 0,
+            states: Vec::new(),
+            linked: false,
+        };
+        let [a] = <[Place<'_>; 1]>::try_from(explored_dirs(top)).ok().unwrap();
+        let nested: Vec<PathBuf> = explored_dirs(a).into_iter().map(|p| p.rel).collect();
+        assert_eq!(nested, vec![Path::new("a").join(RESERVED_DIR)]);
+    }
+
     #[test]
     fn is_reserved_dir_matches_top_level_dirsql() {
         assert!(is_reserved_dir(1, true, OsStr::new(RESERVED_DIR)));

{dirsql-0.4.84 → dirsql-0.4.85}/packages/rust/src/vtab_scaffold.rs

@@ -331,7 +331,7 @@ fn lookup_cost(prefetch: bool) -> f64 {
 fn plan_idx_num(lookup: Option<usize>, prefetch: bool) -> c_int {
     let lookup = lookup.map_or(SCAN_IDX, lookup_idx_num);
     if prefetch {
-        lookup | PREFETCH_IDX
+        lookup + PREFETCH_IDX
     } else {
         lookup
     }

{dirsql-0.4.84 → dirsql-0.4.85}/packages/rust/src/watcher.rs

@@ -1,11 +1,14 @@
 use notify::event::{ModifyKind, RenameMode};
 use notify::{
-    Config, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher as NotifyWatcher,
+    Config, ErrorKind, Event, EventKind, RecommendedWatcher, RecursiveMode,
+    Watcher as NotifyWatcher,
 };
 use std::path::{Path, PathBuf};
 use std::sync::mpsc;
 use std::time::Duration;
 
+const EMFILE: i32 = 24;
+
 /// Events emitted by the file watcher.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum FileEvent {
@@ -74,6 +77,25 @@ impl Watcher {
     }
 }
 
+/// The message for a watcher that failed to start. On inotify, the opaque
+/// limit errors name the exhausted limit and the sysctl that raises it.
+pub(crate) fn describe_watch_error(err: &notify::Error, inotify: bool) -> String {
+    let base = err.to_string();
+    if !inotify {
+        return base;
+    }
+    let (limit, sysctl) = match &err.kind {
+        ErrorKind::Io(io) if io.raw_os_error() == Some(EMFILE) => {
+            ("inotify instance limit", "fs.inotify.max_user_instances")
+        }
+        ErrorKind::MaxFilesWatch => ("inotify watch limit", "fs.inotify.max_user_watches"),
+        _ => return base,
+    };
+    format!(
+        "{base}; the {limit} is likely exhausted: raise it with `sudo sysctl {sysctl}=<higher value>`"
+    )
+}
+
 /// Translate a notify Event into zero or more FileEvents.
 fn translate_event(event: &Event) -> Vec<FileEvent> {
     let mut results = Vec::new();
@@ -106,7 +128,7 @@ fn translate_event(event: &Event) -> Vec<FileEvent> {
     results
 }
 
-// Test fixtures: build `notify::Event`s without the unit tests naming the
+// Test fixtures: build `notify::Event`s and `notify::Error`s without the unit tests naming the
 // `notify::event::*` inner-kind types (the unit-lint isolation rule).
 // `translate_event` matches only the outer variant, so the inner kind is an
 // arbitrary valid value.
@@ -192,6 +214,21 @@ fn access_event(paths: Vec<PathBuf>) -> Event {
     }
 }
 
+#[cfg(test)]
+fn io_error(raw_os_error: i32) -> notify::Error {
+    notify::Error::io(std::io::Error::from_raw_os_error(raw_os_error))
+}
+
+#[cfg(test)]
+fn max_files_watch_error() -> notify::Error {
+    notify::Error::new(ErrorKind::MaxFilesWatch)
+}
+
+#[cfg(test)]
+fn path_not_found_error() -> notify::Error {
+    notify::Error::path_not_found()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -200,6 +237,41 @@ mod tests {
     // `tests/watcher.rs` (unit-lint isolation); only the pure
     // `translate_event` mapping tests belong here.
 
+    #[test]
+    fn describe_watch_error_names_the_instance_limit_for_emfile_on_inotify() {
+        let err = io_error(24);
+        let msg = describe_watch_error(&err, true);
+        assert!(msg.starts_with(&err.to_string()), "{msg}");
+        assert!(msg.contains("inotify instance limit"), "{msg}");
+        assert!(msg.contains("fs.inotify.max_user_instances"), "{msg}");
+    }
+
+    #[test]
+    fn describe_watch_error_names_the_watch_limit_for_max_files_watch_on_inotify() {
+        let err = max_files_watch_error();
+        let msg = describe_watch_error(&err, true);
+        assert!(msg.starts_with(&err.to_string()), "{msg}");
+        assert!(msg.contains("inotify watch limit"), "{msg}");
+        assert!(msg.contains("fs.inotify.max_user_watches"), "{msg}");
+    }
+
+    #[test]
+    fn describe_watch_error_leaves_emfile_alone_off_inotify() {
+        let err = io_error(24);
+        assert_eq!(describe_watch_error(&err, false), err.to_string());
+    }
+
+    #[test]
+    fn describe_watch_error_leaves_other_errors_alone() {
+        let other_io = io_error(2);
+        assert_eq!(describe_watch_error(&other_io, true), other_io.to_string());
+        let not_found = path_not_found_error();
+        assert_eq!(
+            describe_watch_error(&not_found, true),
+            not_found.to_string()
+        );
+    }
+
     #[test]
     fn translate_event_maps_create() {
         let results = translate_event(&create_event(vec![PathBuf::from("/tmp/test.txt")]));