dirsql 0.4.48__tar.gz → 0.4.50__tar.gz

{dirsql-0.4.48 → dirsql-0.4.50}/Cargo.lock

@@ -552,10 +552,11 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.48"
+version = "0.4.50"
 dependencies = [
  "assert_cmd",
  "axum",
+ "base64 0.22.1",
  "blake3",
  "clap",
  "console",
@@ -566,6 +567,7 @@ dependencies = [
  "futures-executor",
  "futures-util",
  "globset",
+ "hex",
  "ignore",
  "indicatif",
  "libc",
@@ -597,7 +599,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.48"
+version = "0.4.50"
 dependencies = [
  "dirsql",
  "pyo3",
@@ -974,6 +976,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
 [[package]]
 name = "http"
 version = "0.2.12"

{dirsql-0.4.48 → dirsql-0.4.50}/PKG-INFO

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

{dirsql-0.4.48 → dirsql-0.4.50}/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.48"
+version = "0.4.50"
 # 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.50/packages/python/changelog.d/2026-09-18-flatten-row-event-in-core.md

@@ -0,0 +1,5 @@
+**Changed**
+
+The extension module now flattens row events through the core's
+`flatten_row_event` instead of its own copy of that match. No user-visible
+change: `RowEvent` fields and `action` values are identical.

dirsql-0.4.50/packages/python/e2e-attestations/claude-1130-codec-crates.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1789748436,
+  "exit_code": 0,
+  "commit": "9468882ee26238c102d59814a212d6c7f9c6be92",
+  "branch": "claude/1130-codec-crates"
+}

dirsql-0.4.50/packages/python/e2e-attestations/claude-1131-flatten-row-event.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1789748553,
+  "exit_code": 0,
+  "commit": "d106fd4917b9dc93978646f6cb6d8f94374af617",
+  "branch": "claude/1131-flatten-row-event"
+}

{dirsql-0.4.48 → dirsql-0.4.50}/packages/python/src/lib.rs

@@ -13,7 +13,7 @@
 #[cfg(feature = "extension-module")]
 mod python {
     use ::dirsql::extension_resolution::{self, ConfigSource, PlanEntry};
-    use ::dirsql::{DirSQL, Extension, Row, RowEvent, Table, Value};
+    use ::dirsql::{DirSQL, Extension, Row, RowEvent, Table, Value, flatten_row_event};
     use pyo3::exceptions::{PyOverflowError, PyRuntimeError, PyValueError};
     use pyo3::prelude::*;
     use pyo3::types::{PyBool, PyByteArray, PyBytes, PyDict, PyInt, PyList};
@@ -279,90 +279,18 @@ mod python {
         PyRuntimeError::new_err(e.to_string())
     }
 
-    /// Pure, GIL-free intermediate for a row event. [`row_event_to_plain`]
-    /// builds it from a core [`RowEvent`] (unit-testable without a Python
-    /// interpreter); [`row_event_to_py`] then marshals it into the
-    /// Python-facing [`PyRowEvent`] (the GIL step).
-    struct PlainRowEvent {
-        table: Option<String>,
-        action: &'static str,
-        row: Option<Row>,
-        old_row: Option<Row>,
-        error: Option<String>,
-        file_path: String,
-    }
-
-    fn row_event_to_plain(event: &RowEvent) -> PlainRowEvent {
-        match event {
-            RowEvent::Insert {
-                table,
-                row,
-                file_path,
-            } => PlainRowEvent {
-                table: Some(table.clone()),
-                action: "insert",
-                row: Some(row.clone()),
-                old_row: None,
-                error: None,
-                file_path: file_path.clone(),
-            },
-            RowEvent::Update {
-                table,
-                old_row,
-                new_row,
-                file_path,
-            } => PlainRowEvent {
-                table: Some(table.clone()),
-                action: "update",
-                row: Some(new_row.clone()),
-                old_row: Some(old_row.clone()),
-                error: None,
-                file_path: file_path.clone(),
-            },
-            RowEvent::Delete {
-                table,
-                row,
-                file_path,
-            } => PlainRowEvent {
-                table: Some(table.clone()),
-                action: "delete",
-                row: Some(row.clone()),
-                old_row: None,
-                error: None,
-                file_path: file_path.clone(),
-            },
-            RowEvent::Error {
-                table,
-                file_path,
-                error,
-            } => PlainRowEvent {
-                table: table.clone(),
-                action: "error",
-                row: None,
-                old_row: None,
-                error: Some(error.clone()),
-                file_path: file_path.to_string_lossy().to_string(),
-            },
-        }
-    }
-
     fn row_event_to_py(py: Python<'_>, event: &RowEvent) -> PyResult<PyRowEvent> {
-        let plain = row_event_to_plain(event);
+        let flat = flatten_row_event(event);
         Ok(PyRowEvent {
-            table: plain.table,
-            action: plain.action.to_string(),
-            row: plain
-                .row
-                .as_ref()
-                .map(|r| value_row_to_py_dict(py, r))
-                .transpose()?,
-            old_row: plain
+            table: flat.table,
+            action: flat.action.to_string(),
+            row: flat.row.map(|r| value_row_to_py_dict(py, r)).transpose()?,
+            old_row: flat
                 .old_row
-                .as_ref()
                 .map(|r| value_row_to_py_dict(py, r))
                 .transpose()?,
-            error: plain.error,
-            file_path: Some(plain.file_path),
+            error: flat.error,
+            file_path: Some(flat.file_path),
         })
     }
 
@@ -609,76 +537,6 @@ mod python {
     mod tests {
         use super::*;
 
-        fn one_row() -> HashMap<String, Value> {
-            HashMap::from([("k".to_string(), Value::Integer(7))])
-        }
-
-        #[test]
-        fn plain_insert_maps_row_and_action() {
-            let p = row_event_to_plain(&RowEvent::Insert {
-                table: "t".into(),
-                row: one_row(),
-                file_path: "/f".into(),
-            });
-            assert_eq!(p.action, "insert");
-            assert_eq!(p.table.as_deref(), Some("t"));
-            assert_eq!(
-                p.row.as_ref().and_then(|r| r.get("k")),
-                Some(&Value::Integer(7))
-            );
-            assert!(p.old_row.is_none());
-            assert!(p.error.is_none());
-            assert_eq!(p.file_path, "/f");
-        }
-
-        #[test]
-        fn plain_update_carries_old_and_new() {
-            let mut new = one_row();
-            new.insert("k".to_string(), Value::Integer(9));
-            let p = row_event_to_plain(&RowEvent::Update {
-                table: "t".into(),
-                old_row: one_row(),
-                new_row: new,
-                file_path: "/f".into(),
-            });
-            assert_eq!(p.action, "update");
-            assert_eq!(
-                p.row.as_ref().and_then(|r| r.get("k")),
-                Some(&Value::Integer(9))
-            );
-            assert_eq!(
-                p.old_row.as_ref().and_then(|r| r.get("k")),
-                Some(&Value::Integer(7))
-            );
-        }
-
-        #[test]
-        fn plain_delete_has_row_no_old() {
-            let p = row_event_to_plain(&RowEvent::Delete {
-                table: "t".into(),
-                row: one_row(),
-                file_path: "/f".into(),
-            });
-            assert_eq!(p.action, "delete");
-            assert!(p.row.is_some());
-            assert!(p.old_row.is_none());
-        }
-
-        #[test]
-        fn plain_error_has_no_row_and_optional_table() {
-            let p = row_event_to_plain(&RowEvent::Error {
-                table: None,
-                file_path: std::path::PathBuf::from("/f"),
-                error: "boom".into(),
-            });
-            assert_eq!(p.action, "error");
-            assert!(p.table.is_none());
-            assert!(p.row.is_none());
-            assert!(p.old_row.is_none());
-            assert_eq!(p.error.as_deref(), Some("boom"));
-            assert_eq!(p.file_path, "/f");
-        }
-
         #[test]
         fn on_file_error_displays_inner() {
             assert_eq!(OnFileError("bad".to_string()).to_string(), "bad");

{dirsql-0.4.48 → dirsql-0.4.50}/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.48"
+version = "0.4.50"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly
@@ -47,6 +47,7 @@ cli = [
     "dep:axum",
     "dep:clap",
     "dep:futures",
+    "dep:hex",
     "dep:reedline",
     "dep:tokio-stream",
     "tokio/rt-multi-thread",
@@ -57,12 +58,16 @@ cli = [
 
 [dependencies]
 axum = { version = "0.8", optional = true }
+base64 = "0.22"
 blake3 = "1"
 clap = { version = "4", features = ["derive"], optional = true }
 console = "0.16.6"
 futures = { version = "0.3", optional = true }
 futures-channel.workspace = true
 globset = "0.4"
+# Hex rendering of BLOB cells in the CLI's JSON output. CLI-only, so a
+# library consumer never pulls it.
+hex = { version = "0.4", optional = true }
 # Hierarchical `.gitignore` matching for path-table scans (the fd/ripgrep
 # semantics), without adopting its walker: the scan keeps `walkdir`.
 ignore = "0.4"

{dirsql-0.4.48 → dirsql-0.4.50}/packages/rust/src/cli/serialize.rs

@@ -26,19 +26,10 @@ fn cell_to_json(value: &CellValue) -> Value {
             .map(Value::Number)
             .unwrap_or(Value::Null),
         CellValue::Text(s) => Value::String(s.clone()),
-        CellValue::Blob(bytes) => Value::String(hex_encode(bytes)),
+        CellValue::Blob(bytes) => Value::String(hex::encode(bytes)),
     }
 }
 
-/// Hex-encode a byte slice, for `BLOB` SQLite values in JSON output.
-fn hex_encode(bytes: &[u8]) -> String {
-    let mut out = String::with_capacity(bytes.len() * 2);
-    for b in bytes {
-        out.push_str(&format!("{b:02x}"));
-    }
-    out
-}
-
 pub(super) fn event_to_json(event: &RowEvent) -> String {
     event_to_value(event).to_string()
 }
@@ -198,6 +189,8 @@ mod tests {
     fn blob_cell_becomes_hex_string() {
         let json = cell_to_json(&CellValue::Blob(vec![0xde, 0xad, 0xbe, 0xef]));
         assert_eq!(json.as_str(), Some("deadbeef"));
+        let padded = cell_to_json(&CellValue::Blob(vec![0x00, 0x0f, 0xff]));
+        assert_eq!(padded.as_str(), Some("000fff"));
     }
 
     #[test]
@@ -205,9 +198,4 @@ mod tests {
         assert!(cell_to_json(&CellValue::Real(f64::NAN)).is_null());
         assert!(cell_to_json(&CellValue::Real(f64::INFINITY)).is_null());
     }
-
-    #[test]
-    fn hex_encode_matches_lowercase_spec() {
-        assert_eq!(hex_encode(&[0x00, 0x0f, 0xff, 0xde, 0xad]), "000fffdead");
-    }
 }

{dirsql-0.4.48 → dirsql-0.4.50}/packages/rust/src/functions.rs

@@ -38,6 +38,8 @@ use std::sync::mpsc::{Receiver, RecvTimeoutError, SyncSender};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+use base64::Engine as _;
+use base64::engine::general_purpose::STANDARD;
 use rusqlite::Connection;
 use rusqlite::functions::FunctionFlags;
 
@@ -357,7 +359,7 @@ fn value_to_json(value: &Value) -> serde_json::Value {
             .map(serde_json::Value::Number)
             .unwrap_or(serde_json::Value::Null),
         Value::Text(s) => serde_json::Value::from(s.as_str()),
-        Value::Blob(bytes) => serde_json::json!({ "$bytes": base64_encode(bytes) }),
+        Value::Blob(bytes) => serde_json::json!({ "$bytes": STANDARD.encode(bytes) }),
     }
 }
 
@@ -428,77 +430,15 @@ fn json_to_sql_value(value: &serde_json::Value) -> Result<Value, String> {
             let encoded = map["$bytes"]
                 .as_str()
                 .ok_or_else(|| "\"$bytes\" must be a base64 string".to_string())?;
-            let bytes = base64_decode(encoded)
-                .ok_or_else(|| "\"$bytes\" is not valid base64".to_string())?;
+            let bytes = STANDARD
+                .decode(encoded)
+                .map_err(|_| "\"$bytes\" is not valid base64".to_string())?;
             Ok(Value::Blob(bytes))
         }
         other => Ok(Value::Text(other.to_string())),
     }
 }
 
-const BASE64_ALPHABET: &[u8; 64] =
-    b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/// Standard base64 with padding. Hand-rolled (~20 lines) rather than a new
-/// dependency for one wire field.
-fn base64_encode(bytes: &[u8]) -> String {
-    let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
-    for chunk in bytes.chunks(3) {
-        let b0 = u32::from(chunk[0]);
-        let b1 = chunk.get(1).map(|b| u32::from(*b));
-        let b2 = chunk.get(2).map(|b| u32::from(*b));
-        let triple = (b0 << 16) | (b1.unwrap_or(0) << 8) | b2.unwrap_or(0);
-        let index = |shift: u32| BASE64_ALPHABET[(triple >> shift & 0x3f) as usize] as char;
-        out.push(index(18));
-        out.push(index(12));
-        out.push(if b1.is_some() { index(6) } else { '=' });
-        out.push(if b2.is_some() { index(0) } else { '=' });
-    }
-    out
-}
-
-/// Decode standard base64 (padding required). `None` on any malformed input.
-fn base64_decode(text: &str) -> Option<Vec<u8>> {
-    let bytes = text.as_bytes();
-    if !bytes.len().is_multiple_of(4) {
-        return None;
-    }
-    let value_of = |b: u8| -> Option<u32> {
-        BASE64_ALPHABET
-            .iter()
-            .position(|c| *c == b)
-            .map(|i| u32::try_from(i).expect("index < 64"))
-    };
-    let mut out = Vec::with_capacity(bytes.len() / 4 * 3);
-    for (i, chunk) in bytes.chunks(4).enumerate() {
-        let last = (i + 1) * 4 == bytes.len();
-        let pad = chunk.iter().filter(|b| **b == b'=').count();
-        // Padding may only close the final chunk, as its last one or two chars.
-        if pad > 0 && (!last || pad > 2 || chunk[..4 - pad].contains(&b'=')) {
-            return None;
-        }
-        let mut triple: u32 = 0;
-        for b in &chunk[..4 - pad] {
-            triple = (triple << 6) | value_of(*b)?;
-        }
-        triple <<= 6 * u32::try_from(pad).expect("pad <= 2");
-        #[expect(
-            clippy::cast_possible_truncation,
-            reason = "each shift isolates one byte"
-        )]
-        {
-            out.push((triple >> 16) as u8);
-            if pad < 2 {
-                out.push((triple >> 8) as u8);
-            }
-            if pad < 1 {
-                out.push(triple as u8);
-            }
-        }
-    }
-    Some(out)
-}
-
 /// The production transport: the spawned worker process, its piped stdin,
 /// and a reader thread draining its stdout line-by-line into a channel (a
 /// blocking read has no timeout; `recv_timeout` on the channel does).
@@ -902,40 +842,6 @@ mod tests {
         );
     }
 
-    // --- base64 ------------------------------------------------------------
-
-    #[test]
-    fn base64_round_trips_every_padding_length() {
-        for bytes in [
-            &b""[..],
-            &b"f"[..],
-            &b"fo"[..],
-            &b"foo"[..],
-            &b"foob"[..],
-            &[0u8, 255, 16, 3][..],
-        ] {
-            let encoded = base64_encode(bytes);
-            assert_eq!(base64_decode(&encoded).as_deref(), Some(bytes), "{encoded}");
-        }
-    }
-
-    #[test]
-    fn base64_known_vectors() {
-        assert_eq!(base64_encode(b"foobar"), "Zm9vYmFy");
-        assert_eq!(base64_encode(b"foob"), "Zm9vYg==");
-        assert_eq!(base64_encode(&[1, 2]), "AQI=");
-        assert_eq!(base64_decode("Zm9vYmFy").as_deref(), Some(&b"foobar"[..]));
-    }
-
-    #[test]
-    fn base64_decode_rejects_malformed_input() {
-        assert_eq!(base64_decode("abc"), None); // not a multiple of 4
-        assert_eq!(base64_decode("a!=="), None); // bad alphabet
-        assert_eq!(base64_decode("ab=c"), None); // padding inside a chunk
-        assert_eq!(base64_decode("ab==cd=="), None); // padding before the last chunk
-        assert_eq!(base64_decode("a==="), None); // over-padding
-    }
-
     // --- defaults -----------------------------------------------------------
 
     #[test]

{dirsql-0.4.48 → dirsql-0.4.50}/packages/rust/src/lib.rs

@@ -36,6 +36,8 @@ pub mod persist;
 #[doc(hidden)]
 pub mod progress;
 #[doc(hidden)]
+pub mod row_event_flat;
+#[doc(hidden)]
 pub mod scanner;
 #[doc(hidden)]
 pub mod sql_literal;
@@ -78,6 +80,8 @@ pub use crate::config::ExtensionSpec as Extension;
 pub use crate::db::{DbError, Value};
 pub use crate::differ::RowEvent;
 #[doc(hidden)]
+pub use crate::row_event_flat::{FlatRowEvent, flatten_row_event};
+#[doc(hidden)]
 pub use crate::watcher::FileEvent as RawFileEvent;
 
 pub type Row = HashMap<String, Value>;

dirsql-0.4.50/packages/rust/src/row_event_flat.rs

@@ -0,0 +1,170 @@
+//! Flattening a [`RowEvent`] into the six-field shape both bindings expose.
+//!
+//! Every binding publishes the same `{table, action, row, old_row, error,
+//! file_path}` record, and none of the decisions behind it are host-specific:
+//! which variant carries an old row, which one may have no table, and the
+//! lowercase action names all belong to the core enum. Only the marshaling of
+//! the borrowed rows into host values is per-binding.
+//!
+//! Rows are borrowed so the clone stays at the binding boundary, where it is
+//! already paid.
+
+use crate::Row;
+#[cfg(test)]
+use crate::db::Value;
+use crate::differ::RowEvent;
+
+/// A [`RowEvent`] reduced to the flat record the bindings publish.
+#[derive(Debug, Clone, PartialEq)]
+pub struct FlatRowEvent<'a> {
+    pub table: Option<String>,
+    pub action: &'static str,
+    pub row: Option<&'a Row>,
+    pub old_row: Option<&'a Row>,
+    pub error: Option<String>,
+    pub file_path: String,
+}
+
+pub fn flatten_row_event(event: &RowEvent) -> FlatRowEvent<'_> {
+    match event {
+        RowEvent::Insert {
+            table,
+            row,
+            file_path,
+        } => FlatRowEvent {
+            table: Some(table.clone()),
+            action: "insert",
+            row: Some(row),
+            old_row: None,
+            error: None,
+            file_path: file_path.clone(),
+        },
+        RowEvent::Update {
+            table,
+            old_row,
+            new_row,
+            file_path,
+        } => FlatRowEvent {
+            table: Some(table.clone()),
+            action: "update",
+            row: Some(new_row),
+            old_row: Some(old_row),
+            error: None,
+            file_path: file_path.clone(),
+        },
+        RowEvent::Delete {
+            table,
+            row,
+            file_path,
+        } => FlatRowEvent {
+            table: Some(table.clone()),
+            action: "delete",
+            row: Some(row),
+            old_row: None,
+            error: None,
+            file_path: file_path.clone(),
+        },
+        RowEvent::Error {
+            table,
+            file_path,
+            error,
+        } => FlatRowEvent {
+            table: table.clone(),
+            action: "error",
+            row: None,
+            old_row: None,
+            error: Some(error.clone()),
+            file_path: file_path.to_string_lossy().to_string(),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use super::*;
+
+    fn one_row(v: i64) -> Row {
+        Row::from([("k".to_string(), Value::Integer(v))])
+    }
+
+    #[test]
+    fn insert_maps_row_and_action() {
+        let event = RowEvent::Insert {
+            table: "t".into(),
+            row: one_row(7),
+            file_path: "/f".into(),
+        };
+        let flat = flatten_row_event(&event);
+        assert_eq!(flat.action, "insert");
+        assert_eq!(flat.table.as_deref(), Some("t"));
+        assert_eq!(flat.row.and_then(|r| r.get("k")), Some(&Value::Integer(7)));
+        assert!(flat.old_row.is_none());
+        assert!(flat.error.is_none());
+        assert_eq!(flat.file_path, "/f");
+    }
+
+    #[test]
+    fn update_carries_new_row_as_row_and_old_row_beside_it() {
+        let event = RowEvent::Update {
+            table: "t".into(),
+            old_row: one_row(7),
+            new_row: one_row(9),
+            file_path: "/f".into(),
+        };
+        let flat = flatten_row_event(&event);
+        assert_eq!(flat.action, "update");
+        assert_eq!(flat.table.as_deref(), Some("t"));
+        assert_eq!(flat.row.and_then(|r| r.get("k")), Some(&Value::Integer(9)));
+        assert_eq!(
+            flat.old_row.and_then(|r| r.get("k")),
+            Some(&Value::Integer(7))
+        );
+        assert!(flat.error.is_none());
+        assert_eq!(flat.file_path, "/f");
+    }
+
+    #[test]
+    fn delete_has_a_row_but_no_old_row() {
+        let event = RowEvent::Delete {
+            table: "t".into(),
+            row: one_row(7),
+            file_path: "/f".into(),
+        };
+        let flat = flatten_row_event(&event);
+        assert_eq!(flat.action, "delete");
+        assert_eq!(flat.table.as_deref(), Some("t"));
+        assert_eq!(flat.row.and_then(|r| r.get("k")), Some(&Value::Integer(7)));
+        assert!(flat.old_row.is_none());
+        assert!(flat.error.is_none());
+        assert_eq!(flat.file_path, "/f");
+    }
+
+    #[test]
+    fn error_has_no_rows_and_stringifies_its_path() {
+        let event = RowEvent::Error {
+            table: None,
+            file_path: PathBuf::from("/f"),
+            error: "boom".into(),
+        };
+        let flat = flatten_row_event(&event);
+        assert_eq!(flat.action, "error");
+        assert!(flat.table.is_none());
+        assert!(flat.row.is_none());
+        assert!(flat.old_row.is_none());
+        assert_eq!(flat.error.as_deref(), Some("boom"));
+        assert_eq!(flat.file_path, "/f");
+    }
+
+    #[test]
+    fn error_keeps_the_table_when_the_variant_names_one() {
+        let event = RowEvent::Error {
+            table: Some("t".into()),
+            file_path: PathBuf::from("/f"),
+            error: "boom".into(),
+        };
+        let flat = flatten_row_event(&event);
+        assert_eq!(flat.table.as_deref(), Some("t"));
+    }
+}