dirsql 0.4.133__tar.gz → 0.4.135__tar.gz

{dirsql-0.4.133 → dirsql-0.4.135}/Cargo.lock

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

{dirsql-0.4.133 → dirsql-0.4.135}/Cargo.toml

@@ -18,7 +18,7 @@ dirsql = { path = "packages/rust" }
 serde = { version = "1", features = ["derive"] }
 # `preserve_order`: a serialized row must keep the projection order the SELECT
 # list asked for, which the default BTreeMap-backed object discards.
-serde_json = { version = "1", features = ["preserve_order"] }
+serde_json = { version = "1", features = ["preserve_order", "float_roundtrip"] }
 regex = "1"
 thiserror = "2"
 tokio = { version = "1", features = ["rt", "sync"] }

{dirsql-0.4.133 → dirsql-0.4.135}/PKG-INFO

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

{dirsql-0.4.133/packages/rust → dirsql-0.4.135}/docs/reference/cli.md

@@ -128,6 +128,11 @@ several lines, and **anything longer than 60 characters is truncated with
 `…`** so one column cannot set the width of every row. `--format json`
 returns the values unaltered.
 
+A text value that is not valid UTF-8 (`CAST(x'ff' AS TEXT)`, `char(55296)`)
+fails the query in every format, with an error naming its column, rather
+than printing replacement characters. Wrap it in `hex()` or `CAST(… AS BLOB)`
+to read its bytes.
+
 Laying the table out to the terminal's width, and paging a long result, are
 both out of scope; pipe to `less` for the latter.
 

{dirsql-0.4.133/packages/rust → dirsql-0.4.135}/docs/reference/config.md

@@ -224,10 +224,10 @@ what its required `on-file` command emits — dirsql injects nothing (see
 | Key | Required | Description |
 |---|---|---|
 | `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 SQL batch, run verbatim — any number of statements. It must create a table called `name`; that table holds the file rows, and only the columns it declares are kept (keys the `on-file` command emits that are not declared are dropped). The rest of the batch is yours: indexes, virtual tables, triggers. See [Batch `ddl`](#batch-ddl). |
+| `ddl` | yes | A SQL batch, run verbatim — any number of statements. It must create a table called `name`; that table holds the file rows, and only the columns it declares are kept (a key the `on-file` command emits fills the declared column it names, compared case-insensitively for ASCII letters as SQL identifiers are; a key naming no declared column is dropped). The rest of the batch is yours: indexes, virtual tables, triggers. See [Batch `ddl`](#batch-ddl). |
 | `glob` | yes | Glob pattern, [anchored](#glob-anchor) at the config file's directory, under the [one glob rule](#glob-rule): `*` matches one level, `**` any depth. Every table whose glob matches a file receives that file's rows — a file can populate multiple tables. A `{name}` is a literal, as in bash and a path-table; the [glob page](./glob.md) has the syntax. |
 | `on-file` | **yes** | A command run once per table, with every matched file's absolute path appended as a trailing argument; its stdout (one JSON object per line) is the table'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`. |
+| `strict` | no (default `false`) | When `true`, rows whose keys do not match the declared columns (compared case-insensitively, as above) 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`. |
 
 `on-file` is required because a table's rows come from nowhere else. dirsql
 does not read file contents or merge filesystem facts on your behalf: the

{dirsql-0.4.133/packages/rust → dirsql-0.4.135}/docs/reference/sdk.md

@@ -223,7 +223,9 @@ db.query_with(sql: &str, params: &Params) -> Result<Vec<Row>>
 
 :::
 
-Executes a SQL query and returns rows keyed by column name.
+Executes a SQL query and returns rows keyed by column name. If a result repeats
+a column name, later occurrences receive `:N` suffixes (for example, `a` and
+`a:1`); suffixes avoid names already present in the result.
 
 **Bind parameters.** `params` reaches SQLite's own parameter binding; the
 values never enter the SQL text, so text holding quotes needs no escaping.

{dirsql-0.4.133 → dirsql-0.4.135}/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.133"
+version = "0.4.135"
 # 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.135/packages/python/changelog.d/2026-11-04-exact-json-floats.md

@@ -0,0 +1 @@
+**Fixed** JSON numbers from `on-file` hooks and worker functions now parse to the exact double: `123456789.12345679` was stored one ULP off as `123456789.1234568`.

{dirsql-0.4.133 → dirsql-0.4.135/packages/python}/docs/reference/cli.md

@@ -128,6 +128,11 @@ several lines, and **anything longer than 60 characters is truncated with
 `…`** so one column cannot set the width of every row. `--format json`
 returns the values unaltered.
 
+A text value that is not valid UTF-8 (`CAST(x'ff' AS TEXT)`, `char(55296)`)
+fails the query in every format, with an error naming its column, rather
+than printing replacement characters. Wrap it in `hex()` or `CAST(… AS BLOB)`
+to read its bytes.
+
 Laying the table out to the terminal's width, and paging a long result, are
 both out of scope; pipe to `less` for the latter.
 

{dirsql-0.4.133 → dirsql-0.4.135/packages/python}/docs/reference/config.md

@@ -224,10 +224,10 @@ what its required `on-file` command emits — dirsql injects nothing (see
 | Key | Required | Description |
 |---|---|---|
 | `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 SQL batch, run verbatim — any number of statements. It must create a table called `name`; that table holds the file rows, and only the columns it declares are kept (keys the `on-file` command emits that are not declared are dropped). The rest of the batch is yours: indexes, virtual tables, triggers. See [Batch `ddl`](#batch-ddl). |
+| `ddl` | yes | A SQL batch, run verbatim — any number of statements. It must create a table called `name`; that table holds the file rows, and only the columns it declares are kept (a key the `on-file` command emits fills the declared column it names, compared case-insensitively for ASCII letters as SQL identifiers are; a key naming no declared column is dropped). The rest of the batch is yours: indexes, virtual tables, triggers. See [Batch `ddl`](#batch-ddl). |
 | `glob` | yes | Glob pattern, [anchored](#glob-anchor) at the config file's directory, under the [one glob rule](#glob-rule): `*` matches one level, `**` any depth. Every table whose glob matches a file receives that file's rows — a file can populate multiple tables. A `{name}` is a literal, as in bash and a path-table; the [glob page](./glob.md) has the syntax. |
 | `on-file` | **yes** | A command run once per table, with every matched file's absolute path appended as a trailing argument; its stdout (one JSON object per line) is the table'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`. |
+| `strict` | no (default `false`) | When `true`, rows whose keys do not match the declared columns (compared case-insensitively, as above) 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`. |
 
 `on-file` is required because a table's rows come from nowhere else. dirsql
 does not read file contents or merge filesystem facts on your behalf: the

{dirsql-0.4.133 → dirsql-0.4.135}/packages/python/docs/reference/sdk.md

@@ -223,7 +223,9 @@ db.query_with(sql: &str, params: &Params) -> Result<Vec<Row>>
 
 :::
 
-Executes a SQL query and returns rows keyed by column name.
+Executes a SQL query and returns rows keyed by column name. If a result repeats
+a column name, later occurrences receive `:N` suffixes (for example, `a` and
+`a:1`); suffixes avoid names already present in the result.
 
 **Bind parameters.** `params` reaches SQLite's own parameter binding; the
 values never enter the SQL text, so text holding quotes needs no escaping.

dirsql-0.4.135/packages/python/e2e-attestations/bot-1580-abs-dotdot-1104.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/query_contract_test.py tests/e2e/on_file_query_test.py tests/e2e/use_case_join_test.py tests/e2e/glob_speed_symlink_test.py tests/e2e/fanout_test.py -x -q",
+  "ran_at": 1793815070,
+  "exit_code": 0,
+  "commit": "5fe39f0e3b4c76172402aa69ecb8b992265d9994",
+  "branch": "bot/1580-abs-dotdot-1104"
+}

dirsql-0.4.135/packages/python/e2e-attestations/bot-1586-float-roundtrip-1104.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/on_file_query_test.py tests/e2e/jsonl_parse_speed_test.py tests/e2e/use_case_transcripts_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1793814794,
+  "exit_code": 0,
+  "commit": "4696a76d81c3080df86c416ef418d3d9b2dc0062",
+  "branch": "bot/1586-float-roundtrip-1104"
+}

dirsql-0.4.135/packages/python/e2e-attestations/bot-1587-hook-key-case-1104.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/on_file_query_test.py tests/e2e/declared_table_name_test.py tests/e2e/query_contract_test.py tests/e2e/jsonl_parse_speed_test.py tests/e2e/frontmatter_parse_speed_test.py -x -q",
+  "ran_at": 1793815109,
+  "exit_code": 0,
+  "commit": "e75ae037dafecb3da6314c6367f2a3618fa0586a",
+  "branch": "bot/1587-hook-key-case-1104"
+}

dirsql-0.4.135/packages/python/e2e-attestations/bot-1593-non-utf8-text-1104.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/query_contract_test.py tests/e2e/on_file_query_test.py tests/e2e/cli_version_test.py -x -q",
+  "ran_at": 1793814772,
+  "exit_code": 0,
+  "commit": "43d8e7c1ebd157e80090a466348da1b9d5aafcda",
+  "branch": "bot/1593-non-utf8-text-1104"
+}

dirsql-0.4.135/packages/python/e2e-attestations/bot-1594-duplicate-columns-1104.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/query_contract_test.py tests/e2e/use_case_join_test.py tests/e2e/on_file_query_test.py -q",
+  "ran_at": 1793815574,
+  "exit_code": 0,
+  "commit": "cc34ffac114dcf2d3dda9dca56e0a09353455ab3",
+  "branch": "bot/1594-duplicate-columns-1104"
+}

dirsql-0.4.135/packages/python/migrations.d/2026-11-04-exact-json-floats.md

@@ -0,0 +1,21 @@
+### Exact JSON float parsing
+
+#### Summary
+
+A JSON float an `on-file` hook or worker function prints is stored as the correctly rounded REAL, where some were one ULP off before. No API or configuration changes are required.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+A REAL column fed from JSON can hold a value one ULP different from before the upgrade: the correct one.
+
+#### Verification
+
+In an empty directory, write `{"v":123456789.12345679}` to `a.ndjson` and run `dirsql query "SELECT v = 123456789.12345679 AS eq FROM './a.ndjson'" --on-file cat --format json`; the output is `[{"eq":1}]`.

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

{dirsql-0.4.133/packages/python → dirsql-0.4.135/packages/rust}/docs/reference/cli.md

@@ -128,6 +128,11 @@ several lines, and **anything longer than 60 characters is truncated with
 `…`** so one column cannot set the width of every row. `--format json`
 returns the values unaltered.
 
+A text value that is not valid UTF-8 (`CAST(x'ff' AS TEXT)`, `char(55296)`)
+fails the query in every format, with an error naming its column, rather
+than printing replacement characters. Wrap it in `hex()` or `CAST(… AS BLOB)`
+to read its bytes.
+
 Laying the table out to the terminal's width, and paging a long result, are
 both out of scope; pipe to `less` for the latter.
 

{dirsql-0.4.133/packages/python → dirsql-0.4.135/packages/rust}/docs/reference/config.md

@@ -224,10 +224,10 @@ what its required `on-file` command emits — dirsql injects nothing (see
 | Key | Required | Description |
 |---|---|---|
 | `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 SQL batch, run verbatim — any number of statements. It must create a table called `name`; that table holds the file rows, and only the columns it declares are kept (keys the `on-file` command emits that are not declared are dropped). The rest of the batch is yours: indexes, virtual tables, triggers. See [Batch `ddl`](#batch-ddl). |
+| `ddl` | yes | A SQL batch, run verbatim — any number of statements. It must create a table called `name`; that table holds the file rows, and only the columns it declares are kept (a key the `on-file` command emits fills the declared column it names, compared case-insensitively for ASCII letters as SQL identifiers are; a key naming no declared column is dropped). The rest of the batch is yours: indexes, virtual tables, triggers. See [Batch `ddl`](#batch-ddl). |
 | `glob` | yes | Glob pattern, [anchored](#glob-anchor) at the config file's directory, under the [one glob rule](#glob-rule): `*` matches one level, `**` any depth. Every table whose glob matches a file receives that file's rows — a file can populate multiple tables. A `{name}` is a literal, as in bash and a path-table; the [glob page](./glob.md) has the syntax. |
 | `on-file` | **yes** | A command run once per table, with every matched file's absolute path appended as a trailing argument; its stdout (one JSON object per line) is the table'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`. |
+| `strict` | no (default `false`) | When `true`, rows whose keys do not match the declared columns (compared case-insensitively, as above) 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`. |
 
 `on-file` is required because a table's rows come from nowhere else. dirsql
 does not read file contents or merge filesystem facts on your behalf: the

{dirsql-0.4.133 → dirsql-0.4.135/packages/rust}/docs/reference/sdk.md

@@ -223,7 +223,9 @@ db.query_with(sql: &str, params: &Params) -> Result<Vec<Row>>
 
 :::
 
-Executes a SQL query and returns rows keyed by column name.
+Executes a SQL query and returns rows keyed by column name. If a result repeats
+a column name, later occurrences receive `:N` suffixes (for example, `a` and
+`a:1`); suffixes avoid names already present in the result.
 
 **Bind parameters.** `params` reaches SQLite's own parameter binding; the
 values never enter the SQL text, so text holding quotes needs no escaping.

{dirsql-0.4.133 → dirsql-0.4.135}/packages/rust/src/db.rs

@@ -49,6 +49,9 @@ pub enum DbError {
 
     #[error("{0}")]
     Params(String),
+
+    #[error("column {0:?} holds text that is not valid UTF-8")]
+    NotUtf8(String),
 }
 
 /// The reserved namespace for dirsql's internal bookkeeping tables. Every
@@ -363,7 +366,7 @@ pub(crate) fn shape_json_rows(
                 .0
                 .iter()
                 .map(|(key, _)| &**key)
-                .filter(|key| !columns.iter().any(|c| c == key))
+                .filter(|key| !columns.iter().any(|c| c.eq_ignore_ascii_case(key)))
                 .collect();
             if !extra.is_empty() {
                 return Err(DbError::SchemaMismatch(format!(
@@ -375,7 +378,7 @@ pub(crate) fn shape_json_rows(
             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.eq_ignore_ascii_case(c)))
                 .collect();
             if !missing.is_empty() {
                 return Err(DbError::SchemaMismatch(format!(
@@ -394,7 +397,7 @@ pub(crate) fn shape_json_rows(
         }
         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.eq_ignore_ascii_case(&key)) {
                 emitted[i] = true;
                 shaped[i] = json_into_value(value);
             }
@@ -755,7 +758,7 @@ impl Db {
         let mut cells = Vec::with_capacity(rows.len());
         for row in rows {
             for (i, column) in columns.iter().enumerate() {
-                emitted[i] |= row.contains_key(column);
+                emitted[i] |= row.keys().any(|key| key.eq_ignore_ascii_case(column));
             }
             let mut row = Self::normalize_against(table, &columns, row, strict)?;
             cells.push(
@@ -782,11 +785,11 @@ impl Db {
             for key in row.keys() {
                 validate_identifier(key)?;
             }
-            let column_set: std::collections::HashSet<&str> =
-                columns.iter().map(|s| s.as_str()).collect();
-            let row_keys: std::collections::HashSet<&str> =
-                row.keys().map(|s| s.as_str()).collect();
-            let extra: Vec<&str> = row_keys.difference(&column_set).copied().collect();
+            let extra: Vec<&str> = row
+                .keys()
+                .map(String::as_str)
+                .filter(|key| !columns.iter().any(|c| c.eq_ignore_ascii_case(key)))
+                .collect();
             if !extra.is_empty() {
                 return Err(DbError::SchemaMismatch(format!(
                     "extra columns not in table {}: {}",
@@ -794,7 +797,11 @@ impl Db {
                     extra.join(", ")
                 )));
             }
-            let missing: Vec<&str> = column_set.difference(&row_keys).copied().collect();
+            let missing: Vec<&str> = columns
+                .iter()
+                .map(String::as_str)
+                .filter(|c| !row.keys().any(|key| key.eq_ignore_ascii_case(c)))
+                .collect();
             if !missing.is_empty() {
                 return Err(DbError::SchemaMismatch(format!(
                     "missing columns for table {}: {}",
@@ -802,15 +809,19 @@ impl Db {
                     missing.join(", ")
                 )));
             }
-            Ok(row)
-        } else {
-            let mut normalized = HashMap::with_capacity(columns.len());
-            for col in columns {
-                let value = row.remove(col).unwrap_or(Value::Null);
-                normalized.insert(col.clone(), value);
-            }
-            Ok(normalized)
         }
+        let mut normalized = HashMap::with_capacity(columns.len());
+        for col in columns {
+            let value = row.remove(col).or_else(|| {
+                let key = row
+                    .keys()
+                    .find(|key| key.eq_ignore_ascii_case(col))?
+                    .clone();
+                row.remove(&key)
+            });
+            normalized.insert(col.clone(), value.unwrap_or(Value::Null));
+        }
+        Ok(normalized)
     }
 
     /// Insert a row into a table.
@@ -1565,8 +1576,8 @@ impl Db {
         let mut spare: Vec<ValueRef<'_>> = Vec::with_capacity(column_names.len());
         while let Some(row) = rows.next()? {
             let mut cells = recycled(spare);
-            for i in 0..column_names.len() {
-                cells.push(row.get_ref(i)?);
+            for (i, column) in column_names.iter().enumerate() {
+                cells.push(utf8_checked(row.get_ref(i)?, column)?);
             }
             on_row(&mut state, &cells);
             spare = recycled(cells);
@@ -1584,7 +1595,7 @@ impl Db {
         while let Some(row) = rows.next()? {
             let mut map = HashMap::new();
             for (i, name) in column_names.iter().enumerate() {
-                let val: rusqlite::types::Value = row.get(i)?;
+                let val = rusqlite::types::Value::from(utf8_checked(row.get_ref(i)?, name)?);
                 map.insert(name.clone(), Value::from(val));
             }
             results.push(map);
@@ -1631,7 +1642,8 @@ impl Db {
             return Err(DbError::WriteForbidden);
         }
         self.scope.warm(&reads);
-        let column_names: Vec<String> = stmt.column_names().iter().map(|s| s.to_string()).collect();
+        let column_names =
+            unique_column_names(stmt.column_names().iter().map(|s| s.to_string()).collect());
         Ok((stmt, column_names, reads))
     }
 
@@ -1900,6 +1912,17 @@ fn fill_cell(cell: &mut Value, source: ValueRef<'_>) {
     }
 }
 
+/// `cell`, unless it is text that is not valid UTF-8: rusqlite panics
+/// converting such text to an owned value.
+fn utf8_checked<'a>(cell: ValueRef<'a>, column: &str) -> Result<ValueRef<'a>> {
+    match cell {
+        ValueRef::Text(bytes) if std::str::from_utf8(bytes).is_err() => {
+            Err(DbError::NotUtf8(column.to_string()))
+        }
+        _ => Ok(cell),
+    }
+}
+
 fn value_ref(value: &Value) -> ValueRef<'_> {
     match value {
         Value::Null => ValueRef::Null,
@@ -1991,6 +2014,27 @@ fn bind(stmt: &mut rusqlite::Statement<'_>, params: &Params) -> Result<()> {
     Ok(())
 }
 
+fn unique_column_names(names: Vec<String>) -> Vec<String> {
+    let reserved: HashSet<String> = names.iter().cloned().collect();
+    let mut used = HashSet::new();
+    names
+        .into_iter()
+        .map(|name| {
+            if used.insert(name.clone()) {
+                return name;
+            }
+            let mut suffix = 1;
+            loop {
+                let candidate = format!("{name}:{suffix}");
+                if !reserved.contains(&candidate) && used.insert(candidate.clone()) {
+                    return candidate;
+                }
+                suffix += 1;
+            }
+        })
+        .collect()
+}
+
 /// `cells` emptied and free to borrow anew, keeping its allocation.
 fn recycled<'a>(mut cells: Vec<ValueRef<'_>>) -> Vec<ValueRef<'a>> {
     cells.clear();
@@ -2013,6 +2057,15 @@ impl From<rusqlite::types::Value> for Value {
 mod tests {
     use super::*;
 
+    #[test]
+    fn duplicate_result_names_avoid_existing_projection_names() {
+        let names = ["a", "a", "a:1", "a"]
+            .into_iter()
+            .map(str::to_string)
+            .collect();
+        assert_eq!(unique_column_names(names), ["a", "a:2", "a:1", "a:3"]);
+    }
+
     #[test]
     fn text_and_blob_values_bind_without_copying() {
         let text = Value::Text("abc".into());
@@ -2322,12 +2375,31 @@ mod tests {
     }
 
     #[test]
-    fn query_each_reads_text_that_is_not_utf8_lossily() {
+    fn query_each_fails_on_text_that_is_not_utf8() {
         let db = titled_docs(&["a"]);
 
-        let (_, rows) = folded(&db, "SELECT CAST(x'ff41' AS TEXT) AS t");
+        let error = db
+            .query_each("SELECT CAST(x'ff41' AS TEXT) AS t", |_| (), |_, _| {})
+            .unwrap_err();
 
-        assert_eq!(rows, [[Value::Text("\u{FFFD}A".into())]]);
+        assert_eq!(
+            error.to_string(),
+            "column \"t\" holds text that is not valid UTF-8"
+        );
+    }
+
+    #[test]
+    fn query_ordered_fails_on_text_that_is_not_utf8() {
+        let db = titled_docs(&["a"]);
+
+        let error = db
+            .query_ordered("SELECT CAST(x'ff41' AS TEXT) AS t")
+            .unwrap_err();
+
+        assert_eq!(
+            error.to_string(),
+            "column \"t\" holds text that is not valid UTF-8"
+        );
     }
 
     fn owned(cell: &ValueRef<'_>) -> Value {
@@ -2376,7 +2448,7 @@ mod tests {
 
         let held = db
             .query_each_ref(
-                "SELECT CAST(x'ff41' AS TEXT) AS t",
+                "SELECT CAST(x'c3a941' AS TEXT) AS t",
                 &Params::default(),
                 |_| Vec::new(),
                 |held: &mut Vec<Vec<u8>>, cells| match cells {
@@ -2386,7 +2458,7 @@ mod tests {
             )
             .unwrap();
 
-        assert_eq!(held, [b"\xffA".to_vec()]);
+        assert_eq!(held, [b"\xc3\xa9A".to_vec()]);
     }
 
     #[test]
@@ -2963,6 +3035,64 @@ mod tests {
         assert_eq!(normalized.len(), 2);
     }
 
+    #[test]
+    fn normalize_row_keys_a_case_differing_key_by_its_column() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (Name TEXT)").unwrap();
+        let row = HashMap::from([("nAME".into(), Value::Text("apple".into()))]);
+        for strict in [false, true] {
+            let normalized = db.normalize_row("t", &row, strict).unwrap();
+            assert_eq!(
+                normalized,
+                HashMap::from([("Name".into(), Value::Text("apple".into()))])
+            );
+        }
+    }
+
+    #[test]
+    fn normalize_row_prefers_the_exact_key_over_a_case_variant() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (name TEXT)").unwrap();
+        let row = HashMap::from([
+            ("NAME".into(), Value::Text("variant".into())),
+            ("name".into(), Value::Text("exact".into())),
+        ]);
+        let normalized = db.normalize_row("t", &row, false).unwrap();
+        assert_eq!(normalized["name"], Value::Text("exact".into()));
+    }
+
+    #[test]
+    fn normalize_row_does_not_fold_non_ascii_case() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (\"é\" TEXT)").unwrap();
+        let row = HashMap::from([("É".into(), Value::Text("x".into()))]);
+        let normalized = db.normalize_row("t", &row, false).unwrap();
+        assert_eq!(normalized["é"], Value::Null);
+    }
+
+    #[test]
+    fn normalize_row_strict_names_exactly_the_unmatched_keys_and_columns() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (Name TEXT, n INTEGER)")
+            .unwrap();
+        let extra = HashMap::from([
+            ("NAME".into(), Value::Null),
+            ("N".into(), Value::Null),
+            ("color".into(), Value::Null),
+        ]);
+        let err = db.normalize_row("t", &extra, true).unwrap_err();
+        assert!(
+            matches!(&err, DbError::SchemaMismatch(m) if m == "extra columns not in table t: color"),
+            "got: {err}"
+        );
+        let missing = HashMap::from([("NAME".into(), Value::Null)]);
+        let err = db.normalize_row("t", &missing, true).unwrap_err();
+        assert!(
+            matches!(&err, DbError::SchemaMismatch(m) if m == "missing columns for table t: n"),
+            "got: {err}"
+        );
+    }
+
     #[test]
     fn insert_and_query_real_value() {
         let db = Db::new().unwrap();
@@ -3988,6 +4118,53 @@ mod tests {
         );
     }
 
+    #[test]
+    fn shape_rows_fills_a_column_from_a_key_differing_only_by_case() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (Id TEXT, n INTEGER)")
+            .unwrap();
+        for strict in [false, true] {
+            let out = db
+                .shape_rows(
+                    "t",
+                    json_rows(serde_json::json!([{"N":1,"iD":"a"}])),
+                    strict,
+                )
+                .unwrap();
+            assert_eq!(out.columns, vec!["Id", "n"]);
+            assert_eq!(out.emitted, vec![true, true]);
+            assert_eq!(
+                out.cells,
+                vec![vec![Value::Text("a".into()), Value::Integer(1)]]
+            );
+        }
+    }
+
+    #[test]
+    fn shape_rows_strict_names_exactly_the_unmatched_keys_and_columns() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (Name TEXT, n INTEGER)")
+            .unwrap();
+        let err = db
+            .shape_rows(
+                "t",
+                json_rows(serde_json::json!([{"NAME":"x","N":1,"color":"red"}])),
+                true,
+            )
+            .unwrap_err();
+        assert!(
+            matches!(&err, DbError::SchemaMismatch(m) if m == "extra columns not in table t: color"),
+            "got: {err}"
+        );
+        let err = db
+            .shape_rows("t", json_rows(serde_json::json!([{"NAME":"x"}])), true)
+            .unwrap_err();
+        assert!(
+            matches!(&err, DbError::SchemaMismatch(m) if m == "missing columns for table t: n"),
+            "got: {err}"
+        );
+    }
+
     #[test]
     fn shape_rows_strict_names_the_extra_columns() {
         let db = Db::new().unwrap();
@@ -5504,6 +5681,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn shape_value_rows_marks_a_column_emitted_by_a_case_differing_key() {
+        let db = Db::new().unwrap();
+        db.create_table("t", "CREATE TABLE t (id INTEGER, Name TEXT)")
+            .unwrap();
+        let rows = vec![HashMap::from([(
+            "nAME".to_string(),
+            Value::Text("a".into()),
+        )])];
+
+        let out = db.shape_value_rows("t", rows, false).unwrap();
+
+        assert_eq!(out.emitted, vec![false, true]);
+        assert_eq!(out.cells, vec![vec![Value::Null, Value::Text("a".into())]]);
+    }
+
     #[test]
     fn shape_value_rows_strict_rejects_a_missing_column() {
         let db = Db::new().unwrap();