dirsql 0.4.23__tar.gz → 0.4.25__tar.gz

{dirsql-0.4.23 → dirsql-0.4.25}/Cargo.lock

@@ -499,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.23"
+version = "0.4.25"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.23 → dirsql-0.4.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.23
+Version: 0.4.25
 Requires-Dist: tomli>=2 ; python_full_version < '3.11'
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory

{dirsql-0.4.23 → dirsql-0.4.25}/dirsql/_dirsql.pyi

@@ -30,6 +30,7 @@ class ExtensionSpec(TypedDict):
 class Table:
     """A table definition. Construct via keyword arguments only."""
 
+    name: str
     ddl: str
     glob: str
     strict: bool
@@ -37,6 +38,7 @@ class Table:
     def __init__(
         self,
         *,
+        name: str,
         ddl: str,
         glob: str,
         on_file: Callable[[str], list[Row]],

{dirsql-0.4.23 → dirsql-0.4.25}/docs/.vitepress/config.ts

@@ -54,6 +54,7 @@ export default defineConfig({
             { text: 'Derive columns from file paths', link: '/howto/columns-from-paths' },
             { text: 'Extract rows from file contents', link: '/howto/extract-from-contents' },
             { text: 'Parse your files into columns', link: '/howto/parse-files-into-columns' },
+            { text: 'Query JSON file contents', link: '/howto/query-json' },
             { text: 'Search documents by meaning', link: '/howto/search-by-meaning' },
             { text: "Skip files you don't want indexed", link: '/howto/skip-files' },
             { text: 'Load a SQLite extension', link: '/howto/load-extension' },

{dirsql-0.4.23 → dirsql-0.4.25}/docs/getting-started.md

@@ -164,6 +164,7 @@ Now create a `.dirsql.toml` that points a table at it:
 ```bash
 cat > .dirsql.toml <<'EOF'
 [[table]]
+name = "notes"
 ddl     = "CREATE TABLE notes (title TEXT, author TEXT)"
 glob    = "notes/**/*.md"
 on-file = "sh note.sh {path}"

{dirsql-0.4.23 → dirsql-0.4.25}/docs/howto/columns-from-paths.md

@@ -33,6 +33,7 @@ Point a table at it in `.dirsql.toml`:
 
 ```toml
 [[table]]
+name = "photos"
 ddl     = "CREATE TABLE photos (year TEXT, month TEXT, basename TEXT)"
 glob    = "photos/*/*/*.jpg"
 on-file = "python3 pathcols.py {path}"

{dirsql-0.4.23/packages/python → dirsql-0.4.25}/docs/howto/define-tables.md

@@ -26,6 +26,7 @@ Then declare the table in `.dirsql.toml`:
 
 ```toml
 [[table]]
+name = "posts"
 ddl     = "CREATE TABLE posts (title TEXT, slug TEXT)"
 glob    = "posts/**/*.md"
 on-file = "python3 extract.py {path}"

{dirsql-0.4.23/packages/python → dirsql-0.4.25}/docs/howto/embed.md

@@ -60,6 +60,7 @@ async def main() -> None:
         "./comments-root",
         tables=[
             Table(
+                name="comments",
                 ddl="CREATE TABLE comments (thread TEXT, author TEXT, body TEXT)",
                 glob="comments/*/*.json",
                 on_file=on_file,
@@ -83,6 +84,7 @@ const db = new DirSQL({
   root: "./comments-root",
   tables: [
     {
+      name: "comments",
       ddl: "CREATE TABLE comments (thread TEXT, author TEXT, body TEXT)",
       glob: "comments/*/*.json",
       onFile: (path) => [
@@ -129,6 +131,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let db = DirSQL::builder()
         .root("./comments-root")
         .table(Table::new(
+            "comments",
             "CREATE TABLE comments (thread TEXT, author TEXT, body TEXT)",
             "comments/*/*.json",
             on_file,

{dirsql-0.4.23/packages/rust → dirsql-0.4.25}/docs/howto/extract-from-contents.md

@@ -18,6 +18,7 @@ stdout works. With [`jq`](https://jqlang.org/):
 
 ```toml
 [[table]]
+name = "books"
 ddl     = "CREATE TABLE books (title TEXT, author TEXT, year INTEGER)"
 glob    = "books/*.json"
 on-file = "jq -c '[{title, author, year}]' {path}"
@@ -53,6 +54,7 @@ row per line, slurp it:
 
 ```toml
 [[table]]
+name = "events"
 ddl     = "CREATE TABLE events (event TEXT, user TEXT)"
 glob    = "logs/*.jsonl"
 on-file = "jq -c -s '.' {path}"
@@ -77,6 +79,9 @@ SQLite value mapping is under
 
 ## Going further
 
+- Just want to read a field or two out of some JSON files? SQLite's JSON
+  operators work directly on a path-table's `content` column, with no config
+  and no command — [Query JSON file contents](./query-json.md).
 - The command re-runs on every startup and on every change to a matched
   file. If it is expensive, [keep the index across restarts](./persist.md).
 - Embedding `dirsql` in a program instead? The SDK's `on_file` callback

{dirsql-0.4.23 → dirsql-0.4.25}/docs/howto/parse-files-into-columns.md

@@ -84,6 +84,7 @@ command in verbatim:
 
 ```toml
 [[table]]
+name = "posts"
 ddl     = "CREATE TABLE posts (title TEXT, author TEXT)"
 glob    = "posts/*.md"
 on-file = "python3 extract.py {path}"

dirsql-0.4.25/docs/howto/query-json.md

@@ -0,0 +1,197 @@
+# Query JSON file contents
+
+A tree of JSON files is already a table — you just have to ask for it. The
+hidden [`content`](../reference/path-tables.md#columns) column holds each
+file's raw text, and SQLite's JSON operators read fields straight out of it.
+No config, no parser, no schema.
+
+## 1. Pull a field out of `content`
+
+Suppose each plugin ships a `metadata.json`:
+
+```
+plugins/alpha/metadata.json
+plugins/beta/metadata.json
+plugins/gamma/metadata.json
+```
+
+```json
+{
+  "name": "alpha",
+  "version": "1.4.0",
+  "disabled": false,
+  "runtime": { "engine": "wasm", "memory_mb": 64 },
+  "tags": ["search", "index"]
+}
+```
+
+The `->>` operator extracts a field. **The key is a string literal, not a bare
+identifier** — this is the one thing that trips everyone up:
+
+```bash
+dirsql query "SELECT content ->> disabled FROM './plugins/alpha/metadata.json'"
+```
+
+```
+dirsql query: SQLite error: no such column: disabled in SELECT content ->> disabled FROM './plugins/alpha/metadata.json' at offset 19
+```
+
+Unquoted, `disabled` is a column name to SQLite's parser, and no such column
+exists. Quote it and the field comes back:
+
+```bash
+dirsql query "SELECT content ->> 'disabled' FROM './plugins/alpha/metadata.json'"
+```
+
+```json
+[{"content ->> 'disabled'":0}]
+```
+
+The expression becomes the column name, so alias it:
+
+```bash
+dirsql query "SELECT content ->> 'disabled' AS disabled FROM './plugins/alpha/metadata.json'"
+```
+
+```json
+[{"disabled":0}]
+```
+
+## 2. Query the whole tree
+
+`content` is a [path-table](../reference/path-tables.md) column, so the same
+expression works over a glob — one row per file:
+
+```bash
+dirsql query "SELECT content ->> 'name' AS name, content ->> 'version' AS version
+              FROM './**/metadata.json' ORDER BY name"
+```
+
+```json
+[{"name":"alpha","version":"1.4.0"},{"name":"beta","version":"0.9.2"},{"name":"gamma","version":"2.0.1"}]
+```
+
+`content` is read only when a query names it, so a glob over a large tree costs
+nothing until you actually reach inside the files.
+
+## 3. Reach nested keys
+
+A key that starts with `$` is a **JSON path**: dotted for nested objects,
+bracketed for array elements. It is still a string literal.
+
+```bash
+dirsql query "SELECT content ->> 'name' AS name,
+                     content ->> '$.runtime.engine' AS engine,
+                     content ->> '$.runtime.memory_mb' AS memory_mb
+              FROM './**/metadata.json' ORDER BY name"
+```
+
+```json
+[{"engine":"wasm","memory_mb":64,"name":"alpha"},{"engine":"native","memory_mb":256,"name":"beta"},{"engine":"wasm","memory_mb":128,"name":"gamma"}]
+```
+
+`content ->> 'name'` and `content ->> '$.name'` are the same lookup — the bare
+form is shorthand for a top-level key. `json_extract(content, '$.name')` is the
+function spelling of the same thing and takes the same paths.
+
+## 4. Filter and aggregate
+
+Extracted fields are ordinary SQL values, so they work in `WHERE`, `GROUP BY`,
+and joins:
+
+```bash
+dirsql query "SELECT path FROM './**/metadata.json'
+              WHERE content ->> 'disabled' = 0 ORDER BY path"
+```
+
+```json
+[{"path":"plugins/alpha/metadata.json"},{"path":"plugins/gamma/metadata.json"}]
+```
+
+To count across an array field, expand it with `json_each`:
+
+```bash
+dirsql query "SELECT t.value AS tag, COUNT(*) AS n
+              FROM './**/metadata.json' AS m, json_each(m.content, '$.tags') AS t
+              GROUP BY tag ORDER BY n DESC, tag"
+```
+
+```json
+[{"n":2,"tag":"index"},{"n":2,"tag":"search"},{"n":1,"tag":"export"},{"n":1,"tag":"rerank"}]
+```
+
+## `->` and `->>`
+
+Both take the same paths; they differ in what they hand back. `->>` returns the
+**SQL value**; `->` returns the **JSON text** of that value, quotes and all:
+
+```bash
+dirsql query "SELECT content -> 'name' AS arrow, content ->> 'name' AS arrow2
+              FROM './plugins/alpha/metadata.json'"
+```
+
+```json
+[{"arrow":"\"alpha\"","arrow2":"alpha"}]
+```
+
+Reach for `->>` to get a value out, and `->` to keep drilling — its JSON result
+is a valid left operand for another `->` or `->>`.
+
+## How JSON types arrive
+
+`->>` maps JSON types onto SQLite's, which has no boolean:
+
+| In the file | In the row |
+| --- | --- |
+| `true` / `false` | `1` / `0` |
+| `null` | `NULL` |
+| number | INTEGER or REAL |
+| string | TEXT, unquoted |
+| object or array | its JSON text |
+| key not present | `NULL` |
+
+So `disabled: false` reads back as `0`, and `WHERE content ->> 'disabled' = 0`
+is how you ask for the enabled ones — `= false` is not SQLite syntax.
+
+A missing key and a `null` value both arrive as `NULL`. Use
+`content -> 'key' IS NULL` to tell them apart: `->` yields the JSON text
+`'null'` for a present null, and SQL `NULL` only when the key is absent.
+
+## When a file isn't valid JSON
+
+The JSON operators reject a non-JSON `content`, and that fails the **whole
+query** — one stray file, no rows at all:
+
+```
+dirsql query: SQLite error: malformed JSON
+```
+
+An empty file counts too: `content` is `''`, which is not valid JSON. Guard the
+scan with `json_valid` when the glob might catch something it shouldn't:
+
+```bash
+dirsql query "SELECT content ->> 'name' AS name FROM './**/metadata.json'
+              WHERE json_valid(content) ORDER BY name"
+```
+
+Files that fail the guard drop out and the rest still answer. A file that is
+unreadable or not UTF-8 has `NULL` content, which is not an error —
+`json_valid(NULL)` is `NULL`, so the guard excludes those too.
+
+## Going further
+
+- Only path-tables expose `content`. A named `[[table]]` has exactly the columns
+  its hook emits ([columns reference](../reference/columns.md)) — reading a
+  field with `->>` there means the hook already emitted it.
+- Doing this on every query re-reads and re-parses every file. When the same
+  tree is queried repeatedly, move the extraction into a table:
+  [Extract rows from file contents](./extract-from-contents.md) declares the
+  columns in a config, and [Parse your files into columns](./parse-files-into-columns.md)
+  prototypes the same parser inline with `--on-file`. Either way the parsed rows
+  are indexed, watched, and [persistable](./persist.md).
+- One JSON file holding *many* records is a parser's job, not an operator's —
+  `json_each` expands an array within a row, but one row per record needs
+  [`on-file`](../reference/hooks.md#on-file).
+- The full operator and function set is SQLite's own:
+  [JSON functions](https://sqlite.org/json1.html). `dirsql` adds nothing to it
+  and takes nothing away.

{dirsql-0.4.23/packages/python → dirsql-0.4.25}/docs/howto/react-to-changes.md

@@ -14,6 +14,7 @@ prints each file's basename:
 ```toml
 # .dirsql.toml
 [[table]]
+name = "files"
 ddl     = "CREATE TABLE files (basename TEXT)"
 glob    = "**/*"
 on-file = '''sh -c 'printf "[{\"basename\":\"%s\"}]" "${1##*/}"' sh {path}'''

{dirsql-0.4.23 → dirsql-0.4.25}/docs/howto/skip-files.md

@@ -22,6 +22,7 @@ Exclude the noise in `.dirsql.toml`:
 ignore = ["notes/drafts/**", "**/*.tmp"]
 
 [[table]]
+name = "notes"
 ddl     = "CREATE TABLE notes (basename TEXT)"
 glob    = "notes/**/*"
 on-file = '''sh -c 'printf "[{\"basename\":\"%s\"}]" "${1##*/}"' sh {path}'''

{dirsql-0.4.23/packages/rust → dirsql-0.4.25}/docs/howto/write-a-plugin.md

@@ -108,6 +108,7 @@ path       = "sqlite_vec"
 entrypoint = "sqlite3_vec_init"
 
 [[table]]
+name = "notes"
 ddl     = "CREATE TABLE notes (path TEXT, text TEXT, embedding TEXT)"
 glob    = "notes/*.md"
 on-file = "uv run --with model2vec python embed.py {path} {root}"

{dirsql-0.4.23/packages/rust → dirsql-0.4.25}/docs/index.md

@@ -34,6 +34,7 @@ db = DirSQL(
     "./my-project",
     tables=[
         Table(
+            name="records",
             ddl="CREATE TABLE records (name TEXT, size INTEGER, type TEXT)",
             glob="data/*.json",
             on_file=lambda path: [json.loads(open(path, encoding="utf-8").read())],
@@ -52,6 +53,7 @@ let db = DirSQL::new(
     "./my-project",
     vec![
         Table::new(
+            "records",
             "CREATE TABLE records (name TEXT, size INTEGER, type TEXT)",
             "data/*.json",
             |path| vec![serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap()],
@@ -70,6 +72,7 @@ const db = new DirSQL({
   root: './my-project',
   tables: [
     new Table({
+      name: 'records',
       ddl: 'CREATE TABLE records (name TEXT, size INTEGER, type TEXT)',
       glob: 'data/*.json',
       onFile: (path) => [JSON.parse(readFileSync(path, 'utf8'))],

{dirsql-0.4.23/packages/rust → dirsql-0.4.25}/docs/reference/config.md

@@ -166,7 +166,8 @@ what its required `on-file` command emits — dirsql injects nothing (see
 
 | Key | Required | Description |
 |---|---|---|
-| `ddl` | yes | A SQLite `CREATE TABLE` statement. The table name is parsed from it. Only the columns declared here are kept; keys the `on-file` command emits that are not declared are dropped. |
+| `name` | yes | The table's SQL name — the name you query it by. Declared, never derived from `ddl`: dirsql does not read the DDL text. The `ddl` must create a table by this name; if it doesn't, loading fails. |
+| `ddl` | yes | A SQLite `CREATE TABLE` statement, run verbatim. Only the columns declared here are kept; keys the `on-file` command emits that are not declared are dropped. |
 | `glob` | yes | Glob pattern matched against root-relative paths. Every table whose glob matches a file receives that file's rows — a file can populate multiple tables. A `{name}` segment is rewritten to `*` (it matches one path segment but captures nothing). |
 | `on-file` | **yes** | A command run once per matched file; its stdout (a JSON array of row objects) becomes the file's rows. Must be non-empty. A `[[table]]` with no `on-file` is a load error (see [parse errors](#parse-errors)). See [Command hooks](./hooks.md#on-file). |
 | `strict` | no (default `false`) | When `true`, rows whose keys do not exactly match the declared columns are rejected with an error: extra keys error, and every declared column must be supplied by the `on-file` output. When `false`, extra keys are dropped and missing columns become `NULL`. |
@@ -180,11 +181,13 @@ instead of declaring a table.
 
 ```toml
 [[table]]
+name = "comments"
 ddl     = "CREATE TABLE comments (path TEXT, author TEXT, body TEXT)"
 glob    = "_comments/*/*.jsonl"
 on-file = "jq -c -s '.' {path}"
 
 [[table]]
+name = "papers"
 ddl     = "CREATE TABLE papers (paper_id TEXT, title TEXT)"
 glob    = "**/meta.json"
 on-file = "uv run python extract_papers.py {path}"
@@ -241,7 +244,16 @@ SDKs raise/reject) when:
 - The TOML is malformed.
 - Any table contains an unknown key (top level, `[dirsql]`, `[[table]]`, or
   `[[dirsql.extension]]`). The error names the offending key.
-- A `[[table]]` entry omits `ddl` or `glob`.
+- A `[[table]]` entry omits `name`, `ddl`, or `glob` (or `name` is
+  empty/whitespace).
+- A `[[table]]` entry's `ddl` runs but creates no table by its `name`. The
+  error carries the entry's name and points at the fix:
+
+  > `table 'messages': its `ddl` ran but created no table called 'messages'. Set `name` to the table the `ddl` creates.`
+
+  dirsql asks SQLite's catalog rather than interpreting the DDL, so quoted
+  (`CREATE TABLE "messages"`), schema-qualified (`main.messages`) and
+  `IF NOT EXISTS` forms all match a plain `name = "messages"`.
 - A `[[table]]` entry omits `on-file` (or it is empty/whitespace). The error
   names the offending glob and points at the fix:
 
@@ -275,11 +287,13 @@ deterministic = true
 timeout       = "600s"
 
 [[table]]
+name = "comments"
 ddl     = "CREATE TABLE comments (author TEXT, body TEXT)"
 glob    = "_comments/*/*.jsonl"
 on-file = "jq -c -s '.' {path}"
 
 [[table]]
+name = "documents"
 ddl     = "CREATE TABLE documents (title TEXT, summary TEXT)"
 glob    = "**/index.md"
 on-file = "uv run python extract_doc.py {path}"

{dirsql-0.4.23 → dirsql-0.4.25}/docs/reference/sdk.md

@@ -317,27 +317,30 @@ rather than waiting — an intentional, language-idiomatic difference.
 ::: code-group
 
 ```python [Python]
-Table(*, ddl: str, glob: str, on_file: Callable[[str], list[dict]], strict: bool = False)
+Table(*, name: str, ddl: str, glob: str, on_file: Callable[[str], list[dict]], strict: bool = False)
 ```
 
 ```typescript [TypeScript]
-new Table({ ddl, glob, onFile, strict? })
+new Table({ name, ddl, glob, onFile, strict? })
 // or a plain object — TableDef and Table are interchangeable:
-{ ddl: string, glob: string, onFile: (path: string) => Record<string, unknown>[], strict?: boolean }
+{ name: string, ddl: string, glob: string, onFile: (path: string) => Record<string, unknown>[], strict?: boolean }
 ```
 
 ```rust [Rust]
-Table::new(ddl, glob, on_file)      // on_file: Fn(&str) -> Vec<Row>, infallible
-Table::try_new(ddl, glob, on_file)  // on_file: Fn(&str) -> Result<Vec<Row>, _>
-Table::strict(ddl, glob, on_file)   // Table::new with strict = true
+Table::new(name, ddl, glob, on_file)      // on_file: Fn(&str) -> Vec<Row>, infallible
+Table::try_new(name, ddl, glob, on_file)  // on_file: Fn(&str) -> Result<Vec<Row>, _>
+Table::strict(name, ddl, glob, on_file)   // Table::new with strict = true
 ```
 
 :::
 
 Maps files to table rows.
 
-- `ddl` — A SQLite `CREATE TABLE` statement; the table name is parsed from
-  it. Table names must be unique across all tables.
+- `name` — The table's SQL name, declared rather than derived from `ddl`.
+  Must be unique across all tables. Building fails if the `ddl` creates no
+  table by this name (checked against SQLite's catalog, before any file is
+  indexed).
+- `ddl` — A SQLite `CREATE TABLE` statement, run verbatim.
 - `glob` — Glob pattern matched against root-relative paths. Every table whose
   glob matches a file receives that file's rows — a file can populate multiple
   tables. A `{name}` segment is rewritten to `*` (it matches one path segment

{dirsql-0.4.23 → dirsql-0.4.25}/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.23"
+version = "0.4.25"
 # 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.25/packages/python/changelog.d/2026-08-20-declared-table-name.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **A table's name is now declared, not derived from `ddl`.** `Table` takes a required keyword-only `name` (`Table(name=..., ddl=..., glob=..., on_file=...)`), and a `[[table]]` entry in a `.dirsql.toml` requires a `name` key. The core no longer parses the DDL text to find the name; a `name` its `ddl` does not create fails at load with an error naming the entry. `Table.name` is now the declared `str` rather than an `Optional[str]` parsed from the DDL. (#962)

{dirsql-0.4.23 → dirsql-0.4.25}/packages/python/docs/.vitepress/config.ts

@@ -54,6 +54,7 @@ export default defineConfig({
             { text: 'Derive columns from file paths', link: '/howto/columns-from-paths' },
             { text: 'Extract rows from file contents', link: '/howto/extract-from-contents' },
             { text: 'Parse your files into columns', link: '/howto/parse-files-into-columns' },
+            { text: 'Query JSON file contents', link: '/howto/query-json' },
             { text: 'Search documents by meaning', link: '/howto/search-by-meaning' },
             { text: "Skip files you don't want indexed", link: '/howto/skip-files' },
             { text: 'Load a SQLite extension', link: '/howto/load-extension' },

{dirsql-0.4.23/packages/rust → dirsql-0.4.25/packages/python}/docs/getting-started.md

@@ -164,6 +164,7 @@ Now create a `.dirsql.toml` that points a table at it:
 ```bash
 cat > .dirsql.toml <<'EOF'
 [[table]]
+name = "notes"
 ddl     = "CREATE TABLE notes (title TEXT, author TEXT)"
 glob    = "notes/**/*.md"
 on-file = "sh note.sh {path}"

{dirsql-0.4.23/packages/rust → dirsql-0.4.25/packages/python}/docs/howto/columns-from-paths.md

@@ -33,6 +33,7 @@ Point a table at it in `.dirsql.toml`:
 
 ```toml
 [[table]]
+name = "photos"
 ddl     = "CREATE TABLE photos (year TEXT, month TEXT, basename TEXT)"
 glob    = "photos/*/*/*.jpg"
 on-file = "python3 pathcols.py {path}"

{dirsql-0.4.23 → dirsql-0.4.25/packages/python}/docs/howto/define-tables.md

@@ -26,6 +26,7 @@ Then declare the table in `.dirsql.toml`:
 
 ```toml
 [[table]]
+name = "posts"
 ddl     = "CREATE TABLE posts (title TEXT, slug TEXT)"
 glob    = "posts/**/*.md"
 on-file = "python3 extract.py {path}"

{dirsql-0.4.23 → dirsql-0.4.25/packages/python}/docs/howto/embed.md

@@ -60,6 +60,7 @@ async def main() -> None:
         "./comments-root",
         tables=[
             Table(
+                name="comments",
                 ddl="CREATE TABLE comments (thread TEXT, author TEXT, body TEXT)",
                 glob="comments/*/*.json",
                 on_file=on_file,
@@ -83,6 +84,7 @@ const db = new DirSQL({
   root: "./comments-root",
   tables: [
     {
+      name: "comments",
       ddl: "CREATE TABLE comments (thread TEXT, author TEXT, body TEXT)",
       glob: "comments/*/*.json",
       onFile: (path) => [
@@ -129,6 +131,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let db = DirSQL::builder()
         .root("./comments-root")
         .table(Table::new(
+            "comments",
             "CREATE TABLE comments (thread TEXT, author TEXT, body TEXT)",
             "comments/*/*.json",
             on_file,

{dirsql-0.4.23 → dirsql-0.4.25}/packages/python/docs/howto/extract-from-contents.md

@@ -18,6 +18,7 @@ stdout works. With [`jq`](https://jqlang.org/):
 
 ```toml
 [[table]]
+name = "books"
 ddl     = "CREATE TABLE books (title TEXT, author TEXT, year INTEGER)"
 glob    = "books/*.json"
 on-file = "jq -c '[{title, author, year}]' {path}"
@@ -53,6 +54,7 @@ row per line, slurp it:
 
 ```toml
 [[table]]
+name = "events"
 ddl     = "CREATE TABLE events (event TEXT, user TEXT)"
 glob    = "logs/*.jsonl"
 on-file = "jq -c -s '.' {path}"
@@ -77,6 +79,9 @@ SQLite value mapping is under
 
 ## Going further
 
+- Just want to read a field or two out of some JSON files? SQLite's JSON
+  operators work directly on a path-table's `content` column, with no config
+  and no command — [Query JSON file contents](./query-json.md).
 - The command re-runs on every startup and on every change to a matched
   file. If it is expensive, [keep the index across restarts](./persist.md).
 - Embedding `dirsql` in a program instead? The SDK's `on_file` callback

{dirsql-0.4.23/packages/rust → dirsql-0.4.25/packages/python}/docs/howto/parse-files-into-columns.md

@@ -84,6 +84,7 @@ command in verbatim:
 
 ```toml
 [[table]]
+name = "posts"
 ddl     = "CREATE TABLE posts (title TEXT, author TEXT)"
 glob    = "posts/*.md"
 on-file = "python3 extract.py {path}"