dirsql 0.4.89__tar.gz → 0.4.90__tar.gz

{dirsql-0.4.89 → dirsql-0.4.90}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.89"
+version = "0.4.90"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -603,7 +603,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.89"
+version = "0.4.90"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.89 → dirsql-0.4.90}/PKG-INFO

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

{dirsql-0.4.89 → dirsql-0.4.90}/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.89"
+version = "0.4.90"
 # 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.90/packages/python/changelog.d/2026-10-06-config-braces.md

@@ -0,0 +1,3 @@
+**Changed** In a declared `[[table]] glob`, `{name}` is a literal, not a
+wildcard, as in a path-table and in bash. The load-time error for a `{name}`
+that collides with a declared column is gone. Write `*` for the old meaning.

dirsql-0.4.90/packages/python/e2e-attestations/claude-1258-config-braces.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791333540,
+  "exit_code": 0,
+  "commit": "37586d9320ebca5d4be159cfe3a523ebcf017884",
+  "branch": "claude/1258-config-braces"
+}

dirsql-0.4.90/packages/python/migrations.d/2026-10-06-config-braces.md

@@ -0,0 +1,40 @@
+### A braced name in a config glob is a literal
+
+#### Summary
+
+`glob = "data/{id}/metadata.json"` used to treat `{id}` as `*`. It now matches
+a directory literally named `{id}`. `{a,b}` alternation is unchanged. A column
+named like a `{name}` no longer errors at load.
+
+#### Required changes
+
+| Before | After |
+| --- | --- |
+| `glob = "data/{id}/metadata.json"` | `glob = "data/*/metadata.json"` |
+
+#### Deprecations removed
+
+- The `CaptureColumnCollision` error: a `{name}` is no longer a capture, so
+  nothing can collide.
+
+#### Behavior changes without code changes
+
+- A config that kept `{name}` in a glob stops matching files and loads no rows.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+mkdir -p 'data/{id}' data/x
+echo '[{"p":"lit"}]' > 'data/{id}/m.json'
+echo '[{"p":"other"}]' > data/x/m.json
+cat > .dirsql.toml <<'TOML'
+[[table]]
+name = "t"
+glob = "data/{id}/m.json"
+ddl = "CREATE TABLE t (p TEXT)"
+on-file = "jq -sc add"
+TOML
+dirsql query "SELECT p FROM t" -c .dirsql.toml
+# expected: [{"p":"lit"}]
+```

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

{dirsql-0.4.89 → dirsql-0.4.90}/packages/rust/src/lib.rs

@@ -199,14 +199,6 @@ pub enum DirSqlError {
         source: Option<BoxError>,
     },
 
-    #[error(
-        "glob capture `{{{placeholder}}}` collides with declared column `{column}`: \
-         captures no longer populate columns, so `{column}` would always be NULL. \
-         Remove `{column}` from the table's DDL, or emit its value from the on-file \
-         hook by splitting the path yourself."
-    )]
-    CaptureColumnCollision { placeholder: String, column: String },
-
     #[error(
         "query() only accepts read-only statements; SQLite classified this statement as a write"
     )]
@@ -1323,18 +1315,6 @@ impl DirSQL {
                     eprintln!("{warning}");
                 }
             }
-            // Reject a `{name}` glob placeholder whose name is also a declared
-            // column: captures no longer populate columns, so it would read
-            // NULL forever. The table exists here either way (freshly created
-            // or restored from cache), so its columns are knowable, and this
-            // runs before any file is ingested — a load-time failure.
-            let declared_columns = db.get_table_columns(&table_name).map_err(map_db_error)?;
-            if let Some(name) = find_capture_column_collision(&table.glob, &declared_columns) {
-                return Err(DirSqlError::CaptureColumnCollision {
-                    placeholder: name.clone(),
-                    column: name,
-                });
-            }
             on_file_map.insert(table_name.clone(), table.hook);
             strict_map.insert(table_name.clone(), table.strict);
             ddl_map.insert(table_name, table.ddl);
@@ -2519,18 +2499,6 @@ pub(crate) fn json_to_value(value: &serde_json::Value) -> Value {
     }
 }
 
-/// Returns the first `{name}` placeholder in `glob` whose name is also one of
-/// `declared_columns`. `None` when the glob has no placeholders or none of
-/// them names a declared column. Pure: the sole input is the glob string and
-/// the column list, so it is exhaustively unit-testable.
-fn find_capture_column_collision(glob: &str, declared_columns: &[String]) -> Option<String> {
-    let declared: std::collections::HashSet<&str> =
-        declared_columns.iter().map(String::as_str).collect();
-    crate::matcher::placeholder_names(glob)
-        .into_iter()
-        .find(|name| declared.contains(name.as_str()))
-}
-
 /// Async wrapper around [`DirSQL`] whose constructor returns immediately while
 /// the initial scan runs on a background thread.
 ///
@@ -4506,54 +4474,6 @@ mod internal_tests {
         assert_eq!(deleted, vec![("gone.txt".to_string(), "t".to_string())]);
     }
 
-    #[test]
-    fn find_capture_column_collision_flags_a_placeholder_naming_a_column() {
-        let declared = vec!["thread_id".to_string(), "basename".to_string()];
-        assert_eq!(
-            find_capture_column_collision("_comments/{thread_id}/*.txt", &declared),
-            Some("thread_id".to_string())
-        );
-    }
-
-    #[test]
-    fn find_capture_column_collision_ignores_a_placeholder_with_no_column() {
-        let declared = vec!["path".to_string(), "basename".to_string()];
-        assert_eq!(
-            find_capture_column_collision("_comments/{thread_id}/*.txt", &declared),
-            None
-        );
-    }
-
-    #[test]
-    fn find_capture_column_collision_none_without_placeholders() {
-        let declared = vec!["thread_id".to_string()];
-        assert_eq!(
-            find_capture_column_collision("_comments/*/*.txt", &declared),
-            None
-        );
-    }
-
-    #[test]
-    fn find_capture_column_collision_returns_first_colliding_placeholder() {
-        let declared = vec!["repo".to_string(), "org".to_string()];
-        assert_eq!(
-            find_capture_column_collision("{org}/{repo}/data.json", &declared),
-            Some("org".to_string())
-        );
-    }
-
-    #[test]
-    fn capture_column_collision_error_names_placeholder_and_fix() {
-        let err = DirSqlError::CaptureColumnCollision {
-            placeholder: "thread_id".to_string(),
-            column: "thread_id".to_string(),
-        };
-        let msg = err.to_string();
-        assert!(msg.contains("thread_id"));
-        assert!(msg.contains("collides"));
-        assert!(msg.contains("on-file"));
-    }
-
     /// A `name` the batch never created: the error has to say what it *did*
     /// create, or a typo gives the reader nothing to compare against.
     #[test]

{dirsql-0.4.89 → dirsql-0.4.90}/packages/rust/src/matcher.rs

@@ -79,8 +79,6 @@ pub struct MatchResult {
     pub table_name: String,
 }
 
-/// A compiled glob pattern. `{name}` placeholders are rewritten to `*` before
-/// compilation, so they are pure match wildcards.
 #[derive(Clone)]
 struct PatternEntry {
     pattern: PathGlob,
@@ -100,72 +98,13 @@ pub struct TableMatcher {
     gitignore: bool,
 }
 
-/// Byte spans of the `{name}` placeholders in `pattern`, in order: `(start,
-/// end, name)` with `end` past the closing brace.
-///
-/// The grammar is exactly `{` `[a-zA-Z_][a-zA-Z0-9_]*` `}`. Anything else --
-/// `{}`, `{1a}`, `{a-b}`, an unclosed `{` -- is not a placeholder and is left
-/// alone, matching the leftmost-first, non-overlapping scan the equivalent
-/// regex performed.
-fn placeholder_spans(pattern: &str) -> Vec<(usize, usize, String)> {
-    let bytes = pattern.as_bytes();
-    let mut spans = Vec::new();
-    let mut i = 0;
-    while i < bytes.len() {
-        if bytes[i] == b'{' {
-            let mut j = i + 1;
-            if j < bytes.len() && (bytes[j].is_ascii_alphabetic() || bytes[j] == b'_') {
-                j += 1;
-                while j < bytes.len() && (bytes[j].is_ascii_alphanumeric() || bytes[j] == b'_') {
-                    j += 1;
-                }
-                if j < bytes.len() && bytes[j] == b'}' {
-                    // Every byte in `i..=j` is ASCII, so these are char boundaries.
-                    spans.push((i, j + 1, pattern[i + 1..j].to_string()));
-                    i = j + 1;
-                    continue;
-                }
-            }
-        }
-        i += 1;
-    }
-    spans
-}
-
-/// Names of the `{name}` placeholders in `pattern`, in order of appearance.
-pub fn placeholder_names(pattern: &str) -> Vec<String> {
-    placeholder_spans(pattern)
-        .into_iter()
-        .map(|(_, _, name)| name)
-        .collect()
-}
-
-/// Rewrite `{name}` placeholders in a glob to `*`, so they match a single path
-/// segment without producing any captured value.
-fn glob_with_placeholders_as_star(pattern: &str) -> String {
-    let spans = placeholder_spans(pattern);
-    if spans.is_empty() {
-        return pattern.to_string();
-    }
-    let mut out = String::with_capacity(pattern.len());
-    let mut last = 0;
-    for (start, end, _) in spans {
-        out.push_str(&pattern[last..start]);
-        out.push('*');
-        last = end;
-    }
-    out.push_str(&pattern[last..]);
-    out
-}
-
 impl TableMatcher {
     /// Build a new matcher from (glob_pattern, table_name) pairs and ignore patterns.
-    /// Glob patterns may contain `{name}` placeholders, which match like `*`.
     pub fn new(mappings: &[(&str, &str)], ignore_patterns: &[&str]) -> Result<Self, GlobError> {
         let mut entries = Vec::new();
         for (pattern, table_name) in mappings {
             entries.push(PatternEntry {
-                pattern: compile_glob(&glob_with_placeholders_as_star(pattern))?,
+                pattern: compile_glob(pattern)?,
                 table_name: table_name.to_string(),
             });
         }
@@ -273,20 +212,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn placeholder_glob_matches_like_a_star() {
-        // A `{name}` placeholder and a `*` compile to the same matcher: both
-        // globs match exactly the same file.
-        let placeholder = TableMatcher::new(&[("data/{id}/metadata.json", "a")], &[]).unwrap();
-        let star = TableMatcher::new(&[("data/*/metadata.json", "a")], &[]).unwrap();
-        let path = Path::new("data/x/metadata.json");
-        assert_eq!(names(&placeholder, "data/x/metadata.json"), vec!["a"]);
-        assert_eq!(
-            placeholder.match_all(path).is_empty(),
-            star.match_all(path).is_empty(),
-        );
-    }
-
     #[test]
     fn match_all_with_nested_path() {
         let matcher = TableMatcher::new(&[("**/*.jsonl", "events")], &[]).unwrap();
@@ -368,105 +293,6 @@ mod tests {
         assert_eq!(names(&matcher, "logs/deep/nested/b.txt"), vec!["t"]);
     }
 
-    #[test]
-    fn placeholder_matches_the_filled_segment() {
-        let matcher =
-            TableMatcher::new(&[("comments/{thread_id}/index.jsonl", "comments")], &[]).unwrap();
-        assert_eq!(
-            names(&matcher, "comments/abc123/index.jsonl"),
-            vec!["comments"]
-        );
-    }
-
-    #[test]
-    fn multiple_placeholders_match() {
-        let matcher = TableMatcher::new(&[("{org}/{repo}/data.json", "repos")], &[]).unwrap();
-        assert_eq!(names(&matcher, "acme/widgets/data.json"), vec!["repos"]);
-    }
-
-    #[test]
-    fn placeholder_no_match_returns_empty() {
-        let matcher =
-            TableMatcher::new(&[("comments/{thread_id}/index.jsonl", "comments")], &[]).unwrap();
-        assert!(matcher.match_all(Path::new("other/file.txt")).is_empty());
-    }
-
-    #[test]
-    fn placeholder_with_double_star_matches() {
-        let matcher = TableMatcher::new(&[("**/{category}/items.json", "items")], &[]).unwrap();
-        assert_eq!(
-            names(&matcher, "shop/electronics/items.json"),
-            vec!["items"]
-        );
-    }
-
-    #[test]
-    fn placeholder_with_question_mark_matches() {
-        let matcher = TableMatcher::new(&[("{name}?.txt", "files")], &[]).unwrap();
-        assert_eq!(names(&matcher, "ab.txt"), vec!["files"]);
-    }
-
-    #[test]
-    fn placeholder_names_lists_names_in_order() {
-        assert_eq!(
-            placeholder_names("{org}/{repo}/data.json"),
-            vec!["org".to_string(), "repo".to_string()]
-        );
-    }
-
-    #[test]
-    fn placeholder_names_empty_when_none() {
-        assert!(placeholder_names("data/*/metadata.json").is_empty());
-    }
-
-    #[test]
-    fn placeholder_names_rejects_everything_outside_the_grammar() {
-        // The grammar is exactly `{` `[a-zA-Z_][a-zA-Z0-9_]*` `}`. Each of these
-        // fails it at a different point -- empty name, a leading digit, a
-        // disallowed interior byte, and a brace that runs off the end of the
-        // pattern -- and all are left alone rather than read as a placeholder.
-        for pattern in ["{}", "{1a}", "{a-b}", "{a b}", "{", "a{", "{a", "{_"] {
-            assert!(
-                placeholder_names(pattern).is_empty(),
-                "`{pattern}` is outside the grammar, so it is not a placeholder"
-            );
-            assert_eq!(
-                glob_with_placeholders_as_star(pattern),
-                pattern,
-                "`{pattern}` is not a placeholder, so the glob is unrewritten"
-            );
-        }
-    }
-
-    #[test]
-    fn placeholder_names_accepts_the_whole_grammar() {
-        // A name starts with a letter or `_` and continues with those plus
-        // digits.
-        assert_eq!(placeholder_names("{a}"), vec!["a".to_string()]);
-        assert_eq!(placeholder_names("{_}"), vec!["_".to_string()]);
-        assert_eq!(placeholder_names("{_a1}"), vec!["_a1".to_string()]);
-        assert_eq!(placeholder_names("{A_1z}"), vec!["A_1z".to_string()]);
-    }
-
-    #[test]
-    fn the_scan_resumes_at_the_byte_after_a_closing_brace() {
-        // Leftmost-first and non-overlapping: back-to-back placeholders both
-        // register, and every byte outside a span survives the rewrite.
-        assert_eq!(
-            placeholder_names("{a}{b}"),
-            vec!["a".to_string(), "b".to_string()]
-        );
-        assert_eq!(glob_with_placeholders_as_star("x{a}y{b}z"), "x*y*z");
-    }
-
-    #[test]
-    fn an_unclosed_brace_leaves_a_later_placeholder_intact() {
-        // The `{` at 0 fails the grammar, so the scan advances one byte at a
-        // time and still finds the real placeholder behind it.
-        assert_eq!(placeholder_names("{a{b}"), vec!["b".to_string()]);
-        assert_eq!(glob_with_placeholders_as_star("{a{b}"), "{a*");
-    }
-
     /// Two files at depth 0, two under `folder/`, two under `folder/sub/`, one
     /// under a sibling directory.
     const FIXTURE: [&str; 7] = [
@@ -602,12 +428,12 @@ mod tests {
     }
 
     #[test]
-    fn a_placeholder_matches_exactly_one_path_segment() {
+    fn a_braced_name_matches_only_itself() {
         let matcher = TableMatcher::new(&[("data/{id}/metadata.json", "a")], &[]).unwrap();
-        assert_eq!(names(&matcher, "data/x/metadata.json"), vec!["a"]);
+        assert_eq!(names(&matcher, "data/{id}/metadata.json"), vec!["a"]);
         assert!(
             matcher
-                .match_all(Path::new("data/x/y/metadata.json"))
+                .match_all(Path::new("data/x/metadata.json"))
                 .is_empty()
         );
     }