dirsql 0.4.114__tar.gz → 0.4.115__tar.gz

{dirsql-0.4.114 → dirsql-0.4.115}/Cargo.lock

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

{dirsql-0.4.114 → dirsql-0.4.115}/PKG-INFO

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

{dirsql-0.4.114 → dirsql-0.4.115}/docs/context/usage.md

@@ -46,6 +46,10 @@ Every row has `path`, `basename`, `dir`, `ext` (no dot, `NULL` when absent), `si
 3. One row per record inside each file, inline: `--on-file <command>` attaches a parser to every path-table in the query. The parser prints one JSON object per line (NDJSON, never an array), and its output replaces the stat columns. See [hooks](https://dirsql.dev/reference/hooks).
 4. Search by meaning: `uvx --with dirsql-plugin-embeddings dirsql "<sql>" --format json` adds `embed()` and `vec_distance_cosine()`. See [search by meaning](https://dirsql.dev/howto/search-by-meaning).
 
+### Browser
+
+When a person wants to explore the tree by hand, `uvx dirsql server --frontend` serves a SQL explorer and prints its URL (`Frontend at http://localhost:7117/`); add `-c .dirsql.toml` to list declared tables. The page runs nothing until **Run** is pressed; press it again to refresh. A config that fails to load shows its diagnostic in the page. It runs until Ctrl-C.
+
 ### Read-only
 
 dirsql never writes to, moves or changes the files it scans, and it rejects mutating SQL. Do not pass `--persist`: it writes a cache database into the directory.

{dirsql-0.4.114/packages/rust → dirsql-0.4.115}/docs/reference/cli.md

@@ -264,9 +264,20 @@ and declared tables reflect the server's index. The page does not use
 
 ```bash
 dirsql server --frontend
+# Frontend at http://localhost:7117/
+# Running at localhost:7117
 dirsql server --frontend -c .dirsql.toml
 ```
 
+Every distribution embeds the same page and script in its binary, so
+`npx dirsql server --frontend`, `uvx dirsql server --frontend`, and the
+`cargo install`ed `dirsql server --frontend` serve the identical UI offline,
+with no separate frontend runtime. In the page, a path-table query such as
+`SELECT basename, size FROM './posts' ORDER BY basename` runs with or
+without `-c`; a declared table such as `SELECT title, author FROM posts`
+needs the config that declares it, passed with `-c`. The frontend stops like
+the API-only server: `SIGINT` or `SIGTERM` exits `0`.
+
 The shell reads `GET /frontend/state`. When the index is ready it returns
 HTTP `200`:
 

{dirsql-0.4.114 → dirsql-0.4.115}/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.114"
+version = "0.4.115"
 # 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.114/packages/rust → dirsql-0.4.115/packages/python}/docs/context/usage.md

@@ -46,6 +46,10 @@ Every row has `path`, `basename`, `dir`, `ext` (no dot, `NULL` when absent), `si
 3. One row per record inside each file, inline: `--on-file <command>` attaches a parser to every path-table in the query. The parser prints one JSON object per line (NDJSON, never an array), and its output replaces the stat columns. See [hooks](https://dirsql.dev/reference/hooks).
 4. Search by meaning: `uvx --with dirsql-plugin-embeddings dirsql "<sql>" --format json` adds `embed()` and `vec_distance_cosine()`. See [search by meaning](https://dirsql.dev/howto/search-by-meaning).
 
+### Browser
+
+When a person wants to explore the tree by hand, `uvx dirsql server --frontend` serves a SQL explorer and prints its URL (`Frontend at http://localhost:7117/`); add `-c .dirsql.toml` to list declared tables. The page runs nothing until **Run** is pressed; press it again to refresh. A config that fails to load shows its diagnostic in the page. It runs until Ctrl-C.
+
 ### Read-only
 
 dirsql never writes to, moves or changes the files it scans, and it rejects mutating SQL. Do not pass `--persist`: it writes a cache database into the directory.

{dirsql-0.4.114 → dirsql-0.4.115/packages/python}/docs/reference/cli.md

@@ -264,9 +264,20 @@ and declared tables reflect the server's index. The page does not use
 
 ```bash
 dirsql server --frontend
+# Frontend at http://localhost:7117/
+# Running at localhost:7117
 dirsql server --frontend -c .dirsql.toml
 ```
 
+Every distribution embeds the same page and script in its binary, so
+`npx dirsql server --frontend`, `uvx dirsql server --frontend`, and the
+`cargo install`ed `dirsql server --frontend` serve the identical UI offline,
+with no separate frontend runtime. In the page, a path-table query such as
+`SELECT basename, size FROM './posts' ORDER BY basename` runs with or
+without `-c`; a declared table such as `SELECT title, author FROM posts`
+needs the config that declares it, passed with `-c`. The frontend stops like
+the API-only server: `SIGINT` or `SIGTERM` exits `0`.
+
 The shell reads `GET /frontend/state`. When the index is ready it returns
 HTTP `200`:
 

dirsql-0.4.115/packages/python/e2e-attestations/bot-1461-wide-read-1015.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_gitignore_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_node_modules_test.py tests/e2e/glob_speed_symlink_test.py tests/e2e/stat_speed_test.py tests/e2e/query_contract_test.py -q",
+  "ran_at": 1792077498,
+  "exit_code": 0,
+  "commit": "7c3d73c0397b24cb4a43a785b80223e5632a8dc5",
+  "branch": "bot/1461-wide-read-1015"
+}

dirsql-0.4.115/packages/python/e2e-attestations/bot-1474-vtab-speed-1014.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ --ignore=tests/e2e/watch_speed_test.py -q",
+  "ran_at": 1792075222,
+  "exit_code": 0,
+  "commit": "111db17ede0ace14d6a6b62eea7561c8d5270277",
+  "branch": "bot/1474-vtab-speed-1014"
+}

dirsql-0.4.115/packages/python/e2e-attestations/bot-1477-onelevel-speed-1015.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_gitignore_test.py tests/e2e/glob_speed_node_modules_test.py tests/e2e/glob_speed_symlink_test.py tests/e2e/query_contract_test.py tests/e2e/fanout_test.py tests/e2e/use_case_join_test.py -q",
+  "ran_at": 1792080077,
+  "exit_code": 0,
+  "commit": "c9a4e46dd7b2af9a444eacc52e308c6fba1cd0cb",
+  "branch": "bot/1477-onelevel-speed-1015"
+}

dirsql-0.4.115/packages/python/e2e-attestations/bot-1481-gitrepo-speed-1015.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_gitignore_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/query_contract_test.py -x -q -s",
+  "ran_at": 1792078679,
+  "exit_code": 0,
+  "commit": "64a91dcf4851c02183542106f7230e7a237f482f",
+  "branch": "bot/1481-gitrepo-speed-1015"
+}

dirsql-0.4.115/packages/python/e2e-attestations/bot-1483-fm-speed-1015.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/frontmatter_parse_speed_test.py tests/e2e/jsonl_parse_speed_test.py tests/e2e/on_file_query_test.py tests/e2e/fanout_test.py tests/e2e/declared_table_name_test.py tests/e2e/query_contract_test.py tests/e2e/use_case_notebook_test.py tests/e2e/use_case_transcripts_test.py tests/e2e/sigint_interrupt_test.py -x -q -s",
+  "ran_at": 1792073709,
+  "exit_code": 0,
+  "commit": "fe211d95faa7bcae8234f897ce0d9c657072ecca",
+  "branch": "bot/1483-fm-speed-1015"
+}

dirsql-0.4.115/packages/python/e2e-attestations/bot-1484-jsonl-speed-1015.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/jsonl_parse_speed_test.py tests/e2e/frontmatter_parse_speed_test.py tests/e2e/on_file_query_test.py tests/e2e/fanout_test.py tests/e2e/declared_table_name_test.py tests/e2e/query_contract_test.py tests/e2e/use_case_transcripts_test.py -x -q -s",
+  "ran_at": 1792074725,
+  "exit_code": 0,
+  "commit": "80a263f8596483f747e652b34ade1dca00bbd31e",
+  "branch": "bot/1484-jsonl-speed-1015"
+}

dirsql-0.4.115/packages/python/e2e-attestations/bot-1526-main-red-1016.json

@@ -0,0 +1,7 @@
+{
+  "command": "true",
+  "ran_at": 1792150362,
+  "exit_code": 0,
+  "commit": "9dc9d4281e34868ec282b87fd8ba07947ccc68d1",
+  "branch": "bot/1526-main-red-1016"
+}

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

{dirsql-0.4.114/packages/python → dirsql-0.4.115/packages/rust}/docs/context/usage.md

@@ -46,6 +46,10 @@ Every row has `path`, `basename`, `dir`, `ext` (no dot, `NULL` when absent), `si
 3. One row per record inside each file, inline: `--on-file <command>` attaches a parser to every path-table in the query. The parser prints one JSON object per line (NDJSON, never an array), and its output replaces the stat columns. See [hooks](https://dirsql.dev/reference/hooks).
 4. Search by meaning: `uvx --with dirsql-plugin-embeddings dirsql "<sql>" --format json` adds `embed()` and `vec_distance_cosine()`. See [search by meaning](https://dirsql.dev/howto/search-by-meaning).
 
+### Browser
+
+When a person wants to explore the tree by hand, `uvx dirsql server --frontend` serves a SQL explorer and prints its URL (`Frontend at http://localhost:7117/`); add `-c .dirsql.toml` to list declared tables. The page runs nothing until **Run** is pressed; press it again to refresh. A config that fails to load shows its diagnostic in the page. It runs until Ctrl-C.
+
 ### Read-only
 
 dirsql never writes to, moves or changes the files it scans, and it rejects mutating SQL. Do not pass `--persist`: it writes a cache database into the directory.

{dirsql-0.4.114/packages/python → dirsql-0.4.115/packages/rust}/docs/reference/cli.md

@@ -264,9 +264,20 @@ and declared tables reflect the server's index. The page does not use
 
 ```bash
 dirsql server --frontend
+# Frontend at http://localhost:7117/
+# Running at localhost:7117
 dirsql server --frontend -c .dirsql.toml
 ```
 
+Every distribution embeds the same page and script in its binary, so
+`npx dirsql server --frontend`, `uvx dirsql server --frontend`, and the
+`cargo install`ed `dirsql server --frontend` serve the identical UI offline,
+with no separate frontend runtime. In the page, a path-table query such as
+`SELECT basename, size FROM './posts' ORDER BY basename` runs with or
+without `-c`; a declared table such as `SELECT title, author FROM posts`
+needs the config that declares it, passed with `-c`. The frontend stops like
+the API-only server: `SIGINT` or `SIGTERM` exits `0`.
+
 The shell reads `GET /frontend/state`. When the index is ready it returns
 HTTP `200`:
 

{dirsql-0.4.114 → dirsql-0.4.115}/packages/rust/src/db.rs

@@ -724,7 +724,7 @@ impl Db {
                 let extra: Vec<&str> = row
                     .0
                     .iter()
-                    .map(|(key, _)| key.as_str())
+                    .map(|(key, _)| &**key)
                     .filter(|key| !columns.iter().any(|c| c == key))
                     .collect();
                 if !extra.is_empty() {
@@ -737,7 +737,7 @@ impl Db {
                 let missing: Vec<&str> = columns
                     .iter()
                     .map(String::as_str)
-                    .filter(|c| !row.0.iter().any(|(key, _)| key == c))
+                    .filter(|c| !row.0.iter().any(|(key, _)| **key == **c))
                     .collect();
                 if !missing.is_empty() {
                     return Err(DbError::SchemaMismatch(format!(
@@ -748,14 +748,14 @@ impl Db {
                 }
             }
             let in_order = row.0.len() == columns.len()
-                && row.0.iter().zip(&columns).all(|((key, _), c)| key == c);
+                && row.0.iter().zip(&columns).all(|((key, _), c)| **key == **c);
             if in_order {
                 cells.push(row.0.into_iter().map(|(_, v)| json_into_value(v)).collect());
                 continue;
             }
             let mut shaped = vec![Value::Null; columns.len()];
             for (key, value) in row.0 {
-                if let Some(i) = columns.iter().position(|c| *c == key) {
+                if let Some(i) = columns.iter().position(|c| **c == *key) {
                     shaped[i] = json_into_value(value);
                 }
             }
@@ -3211,7 +3211,7 @@ mod tests {
                 let serde_json::Value::Object(map) = row else {
                     panic!("row must be an object");
                 };
-                JsonRow(map.into_iter().collect())
+                JsonRow(map.into_iter().map(|(k, v)| (k.into(), v)).collect())
             })
             .collect()
     }

dirsql-0.4.115/packages/rust/src/gitignore_frame.rs

@@ -0,0 +1,145 @@
+use ignore::Match;
+use ignore::gitignore::{Gitignore, GitignoreBuilder, Glob};
+use std::path::Path;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{LazyLock, OnceLock};
+
+/// One directory's `.gitignore` as the walk matches against it.
+///
+/// `Gitignore::matched` borrows a match buffer from a pool that only its
+/// first caller's thread reaches without a lock; every other walk thread
+/// contends on the rest. So each thread slot matches against a copy of its
+/// own, compiled again on first use there.
+pub(crate) struct Frame {
+    gitignore: Gitignore,
+    copies: Box<[OnceLock<Option<Gitignore>>]>,
+    compile: Box<dyn Fn() -> Option<Gitignore> + Send + Sync>,
+}
+
+static SLOTS: LazyLock<usize> =
+    LazyLock::new(|| std::thread::available_parallelism().map_or(1, usize::from));
+
+static NEXT_SLOT: AtomicUsize = AtomicUsize::new(0);
+
+thread_local! {
+    static SLOT: usize = NEXT_SLOT.fetch_add(1, Ordering::Relaxed);
+}
+
+impl Frame {
+    /// The `.gitignore` in `dir`, if one exists. An unparsable file degrades
+    /// to no frame rather than failing the scan.
+    pub(crate) fn load(dir: &Path) -> Option<Frame> {
+        let dir = dir.to_path_buf();
+        Frame::compiled_by(move || {
+            let file = dir.join(".gitignore");
+            if !file.is_file() {
+                return None;
+            }
+            let mut builder = GitignoreBuilder::new(&dir);
+            builder.add(&file);
+            builder.build().ok()
+        })
+    }
+
+    /// A frame for `dir` holding `lines`, as though read from its `.gitignore`.
+    #[cfg(test)]
+    pub(crate) fn from_lines(dir: &Path, lines: &[&str]) -> Frame {
+        let dir = dir.to_path_buf();
+        let lines: Vec<String> = lines.iter().map(|line| line.to_string()).collect();
+        Frame::compiled_by(move || {
+            let mut builder = GitignoreBuilder::new(&dir);
+            for line in &lines {
+                builder.add_line(None, line).ok()?;
+            }
+            builder.build().ok()
+        })
+        .expect("in-memory gitignore lines compile")
+    }
+
+    fn compiled_by(
+        compile: impl Fn() -> Option<Gitignore> + Send + Sync + 'static,
+    ) -> Option<Frame> {
+        Some(Frame {
+            gitignore: compile()?,
+            copies: (0..*SLOTS).map(|_| OnceLock::new()).collect(),
+            compile: Box::new(compile),
+        })
+    }
+
+    pub(crate) fn gitignore(&self) -> &Gitignore {
+        &self.gitignore
+    }
+
+    /// `Gitignore::matched`, on this thread's copy.
+    pub(crate) fn matched(&self, path: &Path, is_dir: bool) -> Match<&Glob> {
+        SLOT.with(|slot| self.copy(*slot)).matched(path, is_dir)
+    }
+
+    /// The copy for thread `slot`, or the shared one when a copy no longer
+    /// compiles.
+    fn copy(&self, slot: usize) -> &Gitignore {
+        self.copies[slot % self.copies.len()]
+            .get_or_init(&*self.compile)
+            .as_ref()
+            .unwrap_or(&self.gitignore)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_frame_matches_as_its_gitignore_does() {
+        let frame = Frame::from_lines(Path::new("/r"), &["*.log", "!keep.log", "dist/"]);
+        assert!(frame.matched(Path::new("/r/a.log"), false).is_ignore());
+        assert!(
+            frame
+                .matched(Path::new("/r/keep.log"), false)
+                .is_whitelist()
+        );
+        assert!(frame.matched(Path::new("/r/dist"), true).is_ignore());
+        assert!(frame.matched(Path::new("/r/dist"), false).is_none());
+    }
+
+    #[test]
+    fn each_thread_compiles_a_copy_of_its_own_once() {
+        let compiled = std::sync::Arc::new(AtomicUsize::new(0));
+        let count = std::sync::Arc::clone(&compiled);
+        let frame = Frame::compiled_by(move || {
+            count.fetch_add(1, Ordering::Relaxed);
+            Some(Gitignore::empty())
+        })
+        .unwrap();
+        frame.matched(Path::new("/r/a"), false);
+        frame.matched(Path::new("/r/b"), false);
+        assert_eq!(compiled.load(Ordering::Relaxed), 2);
+    }
+
+    #[test]
+    fn a_thread_whose_copy_no_longer_compiles_matches_the_first() {
+        let first = std::sync::atomic::AtomicBool::new(true);
+        let frame = Frame::compiled_by(move || {
+            first.swap(false, Ordering::Relaxed).then(|| {
+                let mut builder = GitignoreBuilder::new("/r");
+                builder.add_line(None, "*.log").ok()?;
+                builder.build().ok()
+            })?
+        })
+        .unwrap();
+        assert!(frame.matched(Path::new("/r/a.log"), false).is_ignore());
+    }
+
+    #[test]
+    fn a_frame_serves_more_threads_than_it_has_copies() {
+        let frame = Frame::from_lines(Path::new("/r"), &["*.log"]);
+        let slot = frame.copies.len() * frame.copies.len();
+        assert!(frame.copy(slot).matched("/r/a.log", false).is_ignore());
+    }
+
+    #[test]
+    fn a_frame_reports_the_directory_of_its_gitignore() {
+        let frame = Frame::from_lines(Path::new("/r"), &["*.log"]);
+        assert_eq!(frame.gitignore().path(), Path::new("/r"));
+    }
+}

{dirsql-0.4.114 → dirsql-0.4.115}/packages/rust/src/infer.rs

@@ -23,10 +23,12 @@
 //! Everything here is pure. Reading files, running parsers, and declaring the
 //! schema to SQLite belong to the caller (see [`crate::parsed_vtab`]).
 
-use std::collections::HashMap;
+use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
 use std::fmt;
+use std::sync::Arc;
 
-use serde::de::{Deserializer, MapAccess, Visitor};
+use serde::de::{DeserializeSeed, Deserializer, MapAccess, Visitor};
 
 use crate::Value;
 use crate::json_to_value;
@@ -62,13 +64,17 @@ pub struct Column {
 /// `serde_json::Map` sorts its keys, which would make column order
 /// alphabetical; keeping the pairs in a `Vec` is what makes first-seen
 /// ordering possible at all.
+///
+/// Keys are shared: every row parsed from one block of output holds the same
+/// allocation for a key, so millions of rows cost no per-row key strings to
+/// build or to free on the thread that stores them.
 #[derive(Debug, Clone, Default, PartialEq)]
-pub struct JsonRow(pub Vec<(String, serde_json::Value)>);
+pub struct JsonRow(pub Vec<(Arc<str>, serde_json::Value)>);
 
 impl JsonRow {
     /// The raw JSON value for `key`, or `None` when the row omits it.
     pub fn get(&self, key: &str) -> Option<&serde_json::Value> {
-        self.0.iter().find(|(k, _)| k == key).map(|(_, v)| v)
+        self.0.iter().find(|(k, _)| **k == *key).map(|(_, v)| v)
     }
 }
 
@@ -77,33 +83,55 @@ impl serde::Serialize for JsonRow {
         use serde::ser::SerializeMap;
         let mut map = serializer.serialize_map(Some(self.0.len()))?;
         for (key, value) in &self.0 {
-            map.serialize_entry(key, value)?;
+            map.serialize_entry(&**key, value)?;
         }
         map.end()
     }
 }
 
-impl<'de> serde::Deserialize<'de> for JsonRow {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        struct RowVisitor;
+/// The keys one block of output has used, handed out shared.
+#[derive(Default)]
+struct Keys(HashSet<Arc<str>>);
 
-        impl<'de> Visitor<'de> for RowVisitor {
-            type Value = JsonRow;
+impl Keys {
+    fn intern(&mut self, key: &str) -> Arc<str> {
+        if let Some(seen) = self.0.get(key) {
+            return Arc::clone(seen);
+        }
+        let key: Arc<str> = Arc::from(key);
+        self.0.insert(Arc::clone(&key));
+        key
+    }
+}
 
-            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                f.write_str("a JSON row object")
-            }
+/// A key as the line spells it, borrowed unless it carries an escape.
+#[derive(serde::Deserialize)]
+struct Key<'a>(#[serde(borrow)] Cow<'a, str>);
 
-            fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<JsonRow, A::Error> {
-                let mut pairs = Vec::new();
-                while let Some(pair) = map.next_entry::<String, serde_json::Value>()? {
-                    pairs.push(pair);
-                }
-                Ok(JsonRow(pairs))
-            }
-        }
+/// Deserializes one row, drawing its keys from a block's [`Keys`].
+struct RowSeed<'k>(&'k mut Keys);
+
+impl<'de> DeserializeSeed<'de> for RowSeed<'_> {
+    type Value = JsonRow;
 
-        deserializer.deserialize_map(RowVisitor)
+    fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<JsonRow, D::Error> {
+        deserializer.deserialize_map(self)
+    }
+}
+
+impl<'de> Visitor<'de> for RowSeed<'_> {
+    type Value = JsonRow;
+
+    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("a JSON row object")
+    }
+
+    fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<JsonRow, A::Error> {
+        let mut pairs = Vec::new();
+        while let Some(Key(key)) = map.next_key::<Key<'de>>()? {
+            pairs.push((self.0.intern(&key), map.next_value::<serde_json::Value>()?));
+        }
+        Ok(JsonRow(pairs))
     }
 }
 
@@ -116,6 +144,7 @@ pub fn parse_rows(output: &str) -> Result<Vec<JsonRow>, String> {
 /// [`parse_rows`] for a block that begins after `skipped` earlier lines of the
 /// same output, so an error names its line in the whole output.
 pub(crate) fn parse_rows_at(output: &str, skipped: usize) -> Result<Vec<JsonRow>, String> {
+    let mut keys = Keys::default();
     let mut rows = Vec::new();
     for (index, line) in output.lines().enumerate() {
         let line = line.trim();
@@ -128,13 +157,22 @@ pub(crate) fn parse_rows_at(output: &str, skipped: usize) -> Result<Vec<JsonRow>
                 "line {number} is a JSON array; print one JSON object per line instead"
             ));
         }
-        let row = serde_json::from_str::<JsonRow>(line)
+        let row = parse_row(line, &mut keys)
             .map_err(|e| format!("line {number} is not a JSON object: {e}"))?;
         rows.push(row);
     }
     Ok(rows)
 }
 
+/// One line as a row, rejecting anything after the object as serde_json's
+/// `from_str` does.
+fn parse_row(line: &str, keys: &mut Keys) -> serde_json::Result<JsonRow> {
+    let mut deserializer = serde_json::Deserializer::from_str(line);
+    let row = RowSeed(keys).deserialize(&mut deserializer)?;
+    deserializer.end()?;
+    Ok(row)
+}
+
 /// What the rows have said about one key so far.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Observed {
@@ -194,8 +232,8 @@ pub fn infer_schema(rows: &[JsonRow]) -> Vec<Column> {
 
     for row in rows {
         for (key, value) in &row.0 {
-            let entry = observed.entry(key.as_str()).or_insert_with(|| {
-                order.push(key.clone());
+            let entry = observed.entry(&**key).or_insert_with(|| {
+                order.push(key.to_string());
                 Observed::Untyped
             });
             *entry = entry.observe(value);
@@ -271,11 +309,7 @@ mod tests {
     fn parse_rows_preserves_key_order_rather_than_sorting() {
         let parsed = parse_rows(r#"{"zeta":1,"alpha":2}"#).unwrap();
         assert_eq!(
-            parsed[0]
-                .0
-                .iter()
-                .map(|(k, _)| k.as_str())
-                .collect::<Vec<_>>(),
+            parsed[0].0.iter().map(|(k, _)| &**k).collect::<Vec<_>>(),
             vec!["zeta", "alpha"]
         );
     }
@@ -303,6 +337,28 @@ mod tests {
     fn parse_rows_rejects_a_line_that_is_not_an_object() {
         let err = parse_rows("3").unwrap_err();
         assert!(err.starts_with("line 1 is not a JSON object"), "got: {err}");
+        assert!(err.contains("expected a JSON row object"), "got: {err}");
+    }
+
+    #[test]
+    fn parse_rows_rejects_anything_after_the_object_on_its_line() {
+        let err = parse_rows(r#"{"a":1} {"b":2}"#).unwrap_err();
+        assert!(err.starts_with("line 1 is not a JSON object"), "got: {err}");
+    }
+
+    #[test]
+    fn parse_rows_reads_a_key_spelled_with_an_escape() {
+        let row = &rows(&[r#"{"a\u0062":1}"#])[0];
+        assert_eq!(row.get("ab"), Some(&serde_json::json!(1)));
+    }
+
+    #[test]
+    fn parse_rows_shares_one_allocation_per_key_across_a_blocks_rows() {
+        let parsed = rows(&[r#"{"a":1,"b":2}"#, r#"{"b":3,"a":4}"#]);
+        let key = |row: usize, i: usize| parsed[row].0[i].0.as_ptr();
+        assert_eq!(key(0, 0), key(1, 1));
+        assert_eq!(key(0, 1), key(1, 0));
+        assert_ne!(key(0, 0), key(0, 1));
     }
 
     #[test]