dirsql 0.4.59__tar.gz → 0.4.61__tar.gz

{dirsql-0.4.59 → dirsql-0.4.61}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.59"
+version = "0.4.61"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -585,7 +585,6 @@ dependencies = [
  "tokio-stream",
  "toml",
  "typed-path",
- "walkdir",
 ]
 
 [[package]]
@@ -601,7 +600,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.59"
+version = "0.4.61"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.59 → dirsql-0.4.61}/PKG-INFO

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

{dirsql-0.4.59/packages/rust → dirsql-0.4.61}/docs/reference/config.md

@@ -111,6 +111,7 @@ its `embed()` function exactly this way.
 | `command` | yes (non-empty) | The worker command. Argv-split with the same no-shell quoting rules as [command hooks](./hooks.md#argv-not-a-shell); runs in the config file's directory. |
 | `deterministic` | no (default `false`) | When `true`, the function is registered with `SQLITE_DETERMINISTIC`, letting SQLite cache and reuse results for identical arguments within a query. Only set it when the worker really is a pure function of its arguments. |
 | `timeout` | no | Per-**call** time bound: a positive integer is whole seconds (`timeout = 600`), a string is an integer suffixed `s` or `ms` (`"600s"`, `"250ms"`). When absent, the function mechanism's own 30-second default applies. |
+| `batch` | no | A positive integer: the most calls one **batched request** carries. When set, a statement's values are gathered and sent to the worker in bulk (see [Batching](#batching)); the worker must then speak the batched protocol shape as well as the single-call one. When absent, the worker only ever sees single calls. |
 
 ```toml
 [[dirsql.function]]
@@ -173,6 +174,42 @@ request line in, one response line out, per call:
 - **stderr passes through** to `dirsql`'s stderr, so a worker's progress
   bars and download logs reach the terminal.
 
+### Batching
+
+One round trip per row is the wrong shape for a worker whose cost is
+per-request rather than per-value — an embedding model encodes a list of
+texts in little more time than one. A function declaring `batch = N` is sent
+values in bulk instead:
+
+- **Request:** `{"calls": [[<arg>, ...], ...]}` — up to `N` calls, each
+  encoded exactly as a single call's argument list.
+- **Response:** `{"results": [<response>, ...]}` — one single-call response
+  (`{"ok": ...}` with its optional `"meta"`, or `{"err": ...}`) per call, in
+  order. A per-call `{"err": ...}` fails the query the way it would on a
+  single call. A top-level `{"err": "message"}` instead fails every call in
+  the request.
+- The round trip is bounded by the per-call `timeout` **times the number of
+  calls** in the request.
+
+A batching worker must still answer `{"call": [...]}`: `dirsql` gathers a
+statement's values by running it twice. The first run makes one ordinary
+round trip for the function's first value, binds that reply in place of every
+later distinct argument tuple, and queues those tuples into batched requests
+of at most `N`; the second run is served from the replies. A statement that
+never calls a batched function runs once, exactly as before. Values are
+deduplicated along the way, so the [progress line](./cli.md#progress-reporting)
+counts distinct calls, whichever request shape carried them.
+
+```toml
+[[dirsql.function]]
+name          = "embed"
+args          = [1, 2]
+command       = "dirsql-plugin-embeddings worker"
+deterministic = true
+timeout       = "600s"
+batch         = 256
+```
+
 ## `[[table]]`
 
 Each entry maps a glob pattern to a SQL table. A table's columns are exactly

{dirsql-0.4.59 → dirsql-0.4.61}/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.59"
+version = "0.4.61"
 # 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.59 → dirsql-0.4.61/packages/python}/docs/reference/config.md

@@ -111,6 +111,7 @@ its `embed()` function exactly this way.
 | `command` | yes (non-empty) | The worker command. Argv-split with the same no-shell quoting rules as [command hooks](./hooks.md#argv-not-a-shell); runs in the config file's directory. |
 | `deterministic` | no (default `false`) | When `true`, the function is registered with `SQLITE_DETERMINISTIC`, letting SQLite cache and reuse results for identical arguments within a query. Only set it when the worker really is a pure function of its arguments. |
 | `timeout` | no | Per-**call** time bound: a positive integer is whole seconds (`timeout = 600`), a string is an integer suffixed `s` or `ms` (`"600s"`, `"250ms"`). When absent, the function mechanism's own 30-second default applies. |
+| `batch` | no | A positive integer: the most calls one **batched request** carries. When set, a statement's values are gathered and sent to the worker in bulk (see [Batching](#batching)); the worker must then speak the batched protocol shape as well as the single-call one. When absent, the worker only ever sees single calls. |
 
 ```toml
 [[dirsql.function]]
@@ -173,6 +174,42 @@ request line in, one response line out, per call:
 - **stderr passes through** to `dirsql`'s stderr, so a worker's progress
   bars and download logs reach the terminal.
 
+### Batching
+
+One round trip per row is the wrong shape for a worker whose cost is
+per-request rather than per-value — an embedding model encodes a list of
+texts in little more time than one. A function declaring `batch = N` is sent
+values in bulk instead:
+
+- **Request:** `{"calls": [[<arg>, ...], ...]}` — up to `N` calls, each
+  encoded exactly as a single call's argument list.
+- **Response:** `{"results": [<response>, ...]}` — one single-call response
+  (`{"ok": ...}` with its optional `"meta"`, or `{"err": ...}`) per call, in
+  order. A per-call `{"err": ...}` fails the query the way it would on a
+  single call. A top-level `{"err": "message"}` instead fails every call in
+  the request.
+- The round trip is bounded by the per-call `timeout` **times the number of
+  calls** in the request.
+
+A batching worker must still answer `{"call": [...]}`: `dirsql` gathers a
+statement's values by running it twice. The first run makes one ordinary
+round trip for the function's first value, binds that reply in place of every
+later distinct argument tuple, and queues those tuples into batched requests
+of at most `N`; the second run is served from the replies. A statement that
+never calls a batched function runs once, exactly as before. Values are
+deduplicated along the way, so the [progress line](./cli.md#progress-reporting)
+counts distinct calls, whichever request shape carried them.
+
+```toml
+[[dirsql.function]]
+name          = "embed"
+args          = [1, 2]
+command       = "dirsql-plugin-embeddings worker"
+deterministic = true
+timeout       = "600s"
+batch         = 256
+```
+
 ## `[[table]]`
 
 Each entry maps a glob pattern to a SQL table. A table's columns are exactly

dirsql-0.4.61/packages/python/e2e-attestations/claude-1201-single-walk.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790945578,
+  "exit_code": 0,
+  "commit": "c74aacb34e2aa97f26338176180e7e063f83465b",
+  "branch": "claude/1201-single-walk"
+}

dirsql-0.4.61/packages/python/e2e-attestations/claude-1204-embed-batch.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790942055,
+  "exit_code": 0,
+  "commit": "b9f0529e785dd54fa49496fb3fa48bbcdb14764d",
+  "branch": "claude/1204-embed-batch"
+}

dirsql-0.4.61/packages/python/e2e-attestations/claude-1207-win-argv-quote.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790939617,
+  "exit_code": 0,
+  "commit": "009c015ffa36453da6d92ddec17b5b655b51372f",
+  "branch": "claude/1207-win-argv-quote"
+}

dirsql-0.4.61/packages/python/e2e-attestations/claude-1208-win-nonverbatim-paths.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790939958,
+  "exit_code": 0,
+  "commit": "64a48bb1eff07865a52fc25e1ad50722aced9e45",
+  "branch": "claude/1208-win-nonverbatim-paths"
+}

{dirsql-0.4.59 → dirsql-0.4.61}/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.59"
+version = "0.4.61"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly
@@ -69,7 +69,7 @@ globset = "0.4"
 # 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`.
+# semantics), without adopting its walker: the scan has its own.
 ignore = "0.4"
 indicatif = "0.18.6"
 notify = "7"
@@ -87,7 +87,6 @@ tokio.workspace = true
 tokio-stream = { version = "0.1", features = ["sync"], optional = true }
 toml = "0.8"
 typed-path = "0.12"
-walkdir = "2"
 
 [lints.rust]
 # `deny`, not `forbid`: rusqlite's API imposes five unavoidable `unsafe`

{dirsql-0.4.59/packages/python → dirsql-0.4.61/packages/rust}/docs/reference/config.md

@@ -111,6 +111,7 @@ its `embed()` function exactly this way.
 | `command` | yes (non-empty) | The worker command. Argv-split with the same no-shell quoting rules as [command hooks](./hooks.md#argv-not-a-shell); runs in the config file's directory. |
 | `deterministic` | no (default `false`) | When `true`, the function is registered with `SQLITE_DETERMINISTIC`, letting SQLite cache and reuse results for identical arguments within a query. Only set it when the worker really is a pure function of its arguments. |
 | `timeout` | no | Per-**call** time bound: a positive integer is whole seconds (`timeout = 600`), a string is an integer suffixed `s` or `ms` (`"600s"`, `"250ms"`). When absent, the function mechanism's own 30-second default applies. |
+| `batch` | no | A positive integer: the most calls one **batched request** carries. When set, a statement's values are gathered and sent to the worker in bulk (see [Batching](#batching)); the worker must then speak the batched protocol shape as well as the single-call one. When absent, the worker only ever sees single calls. |
 
 ```toml
 [[dirsql.function]]
@@ -173,6 +174,42 @@ request line in, one response line out, per call:
 - **stderr passes through** to `dirsql`'s stderr, so a worker's progress
   bars and download logs reach the terminal.
 
+### Batching
+
+One round trip per row is the wrong shape for a worker whose cost is
+per-request rather than per-value — an embedding model encodes a list of
+texts in little more time than one. A function declaring `batch = N` is sent
+values in bulk instead:
+
+- **Request:** `{"calls": [[<arg>, ...], ...]}` — up to `N` calls, each
+  encoded exactly as a single call's argument list.
+- **Response:** `{"results": [<response>, ...]}` — one single-call response
+  (`{"ok": ...}` with its optional `"meta"`, or `{"err": ...}`) per call, in
+  order. A per-call `{"err": ...}` fails the query the way it would on a
+  single call. A top-level `{"err": "message"}` instead fails every call in
+  the request.
+- The round trip is bounded by the per-call `timeout` **times the number of
+  calls** in the request.
+
+A batching worker must still answer `{"call": [...]}`: `dirsql` gathers a
+statement's values by running it twice. The first run makes one ordinary
+round trip for the function's first value, binds that reply in place of every
+later distinct argument tuple, and queues those tuples into batched requests
+of at most `N`; the second run is served from the replies. A statement that
+never calls a batched function runs once, exactly as before. Values are
+deduplicated along the way, so the [progress line](./cli.md#progress-reporting)
+counts distinct calls, whichever request shape carried them.
+
+```toml
+[[dirsql.function]]
+name          = "embed"
+args          = [1, 2]
+command       = "dirsql-plugin-embeddings worker"
+deterministic = true
+timeout       = "600s"
+batch         = 256
+```
+
 ## `[[table]]`
 
 Each entry maps a glob pattern to a SQL table. A table's columns are exactly

{dirsql-0.4.59 → dirsql-0.4.61}/packages/rust/src/command.rs

@@ -49,6 +49,63 @@ impl Placeholder {
             value: value.into(),
         }
     }
+
+    /// A placeholder whose value is a filesystem path, handed to the child in
+    /// its plain (non-verbatim) form; see [`non_verbatim`].
+    pub fn path(name: impl Into<String>, path: &str) -> Self {
+        Self::new(name, non_verbatim(path))
+    }
+}
+
+/// The plain form of a Windows verbatim path: `\\?\C:\x` becomes `C:\x` and
+/// `\\?\UNC\server\share\x` becomes `\\server\share\x`. Anything else, and any
+/// verbatim path whose plain spelling would name a different file, is returned
+/// unchanged.
+pub(crate) fn non_verbatim(path: &str) -> String {
+    plain_form(path).unwrap_or_else(|| path.to_string())
+}
+
+fn plain_form(path: &str) -> Option<String> {
+    let rest = path.strip_prefix(r"\\?\")?;
+    let (plain, tail) = if let Some(unc) = rest.strip_prefix(r"UNC\") {
+        if unc.split('\\').count() < 2 {
+            return None;
+        }
+        (format!(r"\\{unc}"), unc)
+    } else {
+        let drive = rest.as_bytes();
+        let is_drive = drive.len() >= 3
+            && drive[0].is_ascii_alphabetic()
+            && drive[1] == b':'
+            && drive[2] == b'\\';
+        if !is_drive {
+            return None;
+        }
+        (rest.to_string(), &rest[3..])
+    };
+    // Win32 rejects or rewrites these, so the plain spelling would not name
+    // the same file; MAX_PATH counts UTF-16 units including the terminator.
+    let same_file = (tail.is_empty() || tail.split('\\').all(is_plain_component))
+        && plain.encode_utf16().count() < 260;
+    same_file.then_some(plain)
+}
+
+fn is_plain_component(name: &str) -> bool {
+    let invalid_char = |c: char| c < ' ' || r#"/<>:"|?*"#.contains(c);
+    let stem = name
+        .split_once('.')
+        .map_or(name, |(stem, _)| stem)
+        .trim_end_matches(' ');
+    let reserved = matches!(
+        stem.to_ascii_uppercase().as_bytes(),
+        b"CON"
+            | b"PRN"
+            | b"AUX"
+            | b"NUL"
+            | [b'C', b'O', b'M', b'1'..=b'9']
+            | [b'L', b'P', b'T', b'1'..=b'9']
+    );
+    !name.is_empty() && !name.ends_with(['.', ' ']) && !name.contains(invalid_char) && !reserved
 }
 
 /// A successful command run.
@@ -119,8 +176,8 @@ pub fn run_command(
     let argv = build_argv(command, placeholders)?;
     // `build_argv` guarantees a non-empty argv.
     let mut cmd = Command::new(&argv[0]);
-    cmd.args(&argv[1..])
-        .current_dir(cwd)
+    push_args(&mut cmd, &argv[1..]);
+    cmd.current_dir(cwd)
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .stdin(if stdin_payload.is_some() {
@@ -193,6 +250,20 @@ pub fn run_command(
     }
 }
 
+// One fn with cfg blocks rather than two cfg'd fns: cargo-mutants mutates
+// the uncompiled twin too, and no test on a Linux gate can kill that mutant.
+fn push_args(cmd: &mut Command, args: &[String]) {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        for arg in args {
+            cmd.raw_arg(quote_windows_arg(arg));
+        }
+    }
+    #[cfg(not(windows))]
+    cmd.args(args);
+}
+
 fn spawn_error(program: &str, source: std::io::Error, cwd: &Path) -> CommandError {
     // A missing cwd fails the child's chdir with `NotFound` too.
     if !searched_path(program, source.kind()) || !cwd.is_dir() {
@@ -244,6 +315,35 @@ pub(crate) fn build_argv(
     Ok(argv)
 }
 
+/// Quote `arg` for a Windows command line by the MS C-runtime rules, always
+/// wrapped in double quotes: an MSYS/Cygwin child globs, brace-expands and
+/// unescapes any unquoted word, while an MSVCRT child parses the quoted form
+/// back to `arg` exactly.
+#[cfg_attr(not(windows), allow(dead_code))]
+pub(crate) fn quote_windows_arg(arg: &str) -> String {
+    let mut out = String::with_capacity(arg.len() + 2);
+    out.push('"');
+    let mut backslashes = 0;
+    for ch in arg.chars() {
+        match ch {
+            '\\' => backslashes += 1,
+            '"' => {
+                out.extend(std::iter::repeat_n('\\', backslashes * 2 + 1));
+                out.push('"');
+                backslashes = 0;
+            }
+            _ => {
+                out.extend(std::iter::repeat_n('\\', backslashes));
+                out.push(ch);
+                backslashes = 0;
+            }
+        }
+    }
+    out.extend(std::iter::repeat_n('\\', backslashes * 2));
+    out.push('"');
+    out
+}
+
 /// Replace every `{name}` in `token` with its placeholder value in a single
 /// left-to-right pass. Injected values are never re-scanned, so an untrusted
 /// value containing `{…}` is inert. Unknown `{…}` sequences are left literal.
@@ -315,6 +415,117 @@ mod tests {
         build_argv(command, placeholders).expect("valid command")
     }
 
+    fn unchanged(path: &str) {
+        assert_eq!(non_verbatim(path), path);
+    }
+
+    #[test]
+    fn non_verbatim_strips_a_verbatim_drive_path() {
+        assert_eq!(
+            non_verbatim(r"\\?\C:\Users\runner\in_cwd.txt"),
+            r"C:\Users\runner\in_cwd.txt"
+        );
+        assert_eq!(non_verbatim(r"\\?\d:\x"), r"d:\x");
+        assert_eq!(non_verbatim(r"\\?\C:\my file.txt"), r"C:\my file.txt");
+    }
+
+    #[test]
+    fn non_verbatim_strips_a_verbatim_drive_root() {
+        assert_eq!(non_verbatim(r"\\?\C:\"), r"C:\");
+    }
+
+    #[test]
+    fn non_verbatim_rewrites_a_verbatim_unc_path() {
+        assert_eq!(
+            non_verbatim(r"\\?\UNC\server\share\dir\f.txt"),
+            r"\\server\share\dir\f.txt"
+        );
+        assert_eq!(non_verbatim(r"\\?\UNC\server\share"), r"\\server\share");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_plain_paths_unchanged() {
+        unchanged(r"C:\Users\runner\f.txt");
+        unchanged(r"\\server\share\f.txt");
+        unchanged("/tmp/root/f.txt");
+        unchanged("relative/f.txt");
+        unchanged("");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_verbatim_forms_without_a_drive_or_unc_unchanged() {
+        unchanged(r"\\?\GLOBALROOT\Device\HarddiskVolume1\f.txt");
+        unchanged(r"\\?\Volume{0b1c2d3e-0000-0000-0000-100000000000}\f.txt");
+        unchanged(r"\\?\C:");
+        unchanged(r"\\?\C:x");
+        unchanged(r"\\?\1:\x");
+        unchanged(r"\\?\");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_an_incomplete_unc_unchanged() {
+        unchanged(r"\\?\UNC\");
+        unchanged(r"\\?\UNC\server");
+        unchanged(r"\\?\UNC\server\");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_components_win32_would_reinterpret_unchanged() {
+        unchanged(r"\\?\C:\a\..\b");
+        unchanged(r"\\?\C:\a\.\b");
+        unchanged(r"\\?\C:\a\\b");
+        unchanged(r"\\?\C:\a\");
+        unchanged(r"\\?\C:\trailing.");
+        unchanged(r"\\?\C:\trailing ");
+        unchanged(r"\\?\C:\a/b");
+        unchanged(r"\\?\C:\a?b");
+        unchanged(r"\\?\C:\a*b");
+        unchanged(r"\\?\C:\a:b");
+        unchanged(r#"\\?\C:\a"b"#);
+        unchanged(r"\\?\C:\a<b");
+        unchanged(r"\\?\C:\a>b");
+        unchanged(r"\\?\C:\a|b");
+        unchanged("\\\\?\\C:\\a\u{1}b");
+        unchanged(r"\\?\UNC\server\share\..\x");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_reserved_device_names_unchanged() {
+        for name in [
+            "CON", "con", "PRN", "AUX", "NUL", "nul.txt", "NUL .txt", "COM1", "COM9", "LPT1",
+            "lpt9.log",
+        ] {
+            unchanged(&format!(r"\\?\C:\dir\{name}"));
+        }
+    }
+
+    #[test]
+    fn non_verbatim_strips_names_that_only_resemble_device_names() {
+        for name in [
+            "CONSOLE", "NULL.txt", "COM0", "COM10", "LPT", "xCON", "AUXa",
+        ] {
+            assert_eq!(
+                non_verbatim(&format!(r"\\?\C:\dir\{name}")),
+                format!(r"C:\dir\{name}")
+            );
+        }
+    }
+
+    #[test]
+    fn non_verbatim_strips_up_to_max_path_and_no_further() {
+        let fits = format!(r"C:\{}", "a".repeat(256));
+        assert_eq!(fits.encode_utf16().count(), 259);
+        assert_eq!(non_verbatim(&format!(r"\\?\{fits}")), fits);
+        unchanged(&format!(r"\\?\C:\{}", "a".repeat(257)));
+    }
+
+    #[test]
+    fn path_placeholder_carries_the_non_verbatim_value() {
+        let placeholder = Placeholder::path("path", r"\\?\C:\a\f.txt");
+        assert_eq!(placeholder.name, "path");
+        assert_eq!(placeholder.value, r"C:\a\f.txt");
+    }
+
     #[test]
     fn splits_on_whitespace_without_placeholders() {
         assert_eq!(argv("echo hello world", &[]), ["echo", "hello", "world"]);
@@ -402,6 +613,47 @@ mod tests {
         assert_eq!(argv("run", &[Placeholder::new("path", "/tmp/x")]), ["run"]);
     }
 
+    #[test]
+    fn windows_quoting_wraps_a_plain_arg_in_quotes() {
+        assert_eq!(quote_windows_arg("hello"), r#""hello""#);
+    }
+
+    #[test]
+    fn windows_quoting_keeps_an_empty_arg_as_an_empty_quoted_word() {
+        assert_eq!(quote_windows_arg(""), r#""""#);
+    }
+
+    #[test]
+    fn windows_quoting_quotes_glob_and_brace_characters() {
+        assert_eq!(quote_windows_arg("[{}]"), r#""[{}]""#);
+        assert_eq!(quote_windows_arg("a?b*c"), r#""a?b*c""#);
+    }
+
+    #[test]
+    fn windows_quoting_leaves_backslashes_not_before_a_quote_alone() {
+        assert_eq!(
+            quote_windows_arg(r"\\?\C:\Users\x.txt"),
+            r#""\\?\C:\Users\x.txt""#
+        );
+    }
+
+    #[test]
+    fn windows_quoting_doubles_trailing_backslashes_before_the_closing_quote() {
+        assert_eq!(quote_windows_arg(r"C:\dir\"), r#""C:\dir\\""#);
+        assert_eq!(quote_windows_arg(r"a\\"), r#""a\\\\""#);
+    }
+
+    #[test]
+    fn windows_quoting_escapes_embedded_quotes() {
+        assert_eq!(quote_windows_arg(r#"[{"n":1}]"#), r#""[{\"n\":1}]""#);
+    }
+
+    #[test]
+    fn windows_quoting_doubles_backslashes_before_an_embedded_quote() {
+        assert_eq!(quote_windows_arg(r#"a\"b"#), r#""a\\\"b""#);
+        assert_eq!(quote_windows_arg(r#"a\\"b"#), r#""a\\\\\"b""#);
+    }
+
     #[test]
     fn extract_payload_takes_the_last_non_empty_line() {
         assert_eq!(

{dirsql-0.4.59 → dirsql-0.4.61}/packages/rust/src/config.rs

@@ -45,6 +45,9 @@ pub enum ConfigError {
     )]
     InvalidFunctionTimeout { name: String, value: String },
 
+    #[error("[[dirsql.function]] '{name}': 'batch' must be a positive integer, got {value}")]
+    InvalidFunctionBatch { name: String, value: String },
+
     #[error("Field '{0}' must not be empty")]
     EmptyField(&'static str),
 
@@ -212,6 +215,11 @@ pub struct FunctionSpec {
     /// Optional per-round-trip-call timeout, overriding the function
     /// mechanism's own 30-second default.
     pub timeout: Option<Duration>,
+    /// Optional cap on the calls one batched request carries. When set, a
+    /// statement's values are sent to the worker in bulk (see
+    /// `dirsql::functions`); when absent the worker only ever sees single
+    /// calls.
+    pub batch: Option<usize>,
 }
 
 /// Configuration for a single table.
@@ -267,6 +275,9 @@ struct RawFunction {
     command: Option<String>,
     deterministic: Option<bool>,
     timeout: Option<RawFunctionTimeout>,
+    // Any shape, so a non-integer hits the same actionable error as a
+    // non-positive one.
+    batch: Option<toml::Value>,
 }
 
 /// The `timeout` key accepts positive whole seconds (`timeout = 600`) or a
@@ -417,12 +428,27 @@ fn parse_function(raw: RawFunction) -> Result<FunctionSpec> {
         Some(raw_timeout) => Some(parse_function_timeout(&name, &raw_timeout)?),
     };
 
+    let batch = match raw.batch {
+        None => None,
+        Some(value) => Some(
+            value
+                .as_integer()
+                .and_then(|n| usize::try_from(n).ok())
+                .filter(|n| *n > 0)
+                .ok_or_else(|| ConfigError::InvalidFunctionBatch {
+                    name: name.clone(),
+                    value: value.to_string(),
+                })?,
+        ),
+    };
+
     Ok(FunctionSpec {
         name,
         args,
         command,
         deterministic: raw.deterministic.unwrap_or(false),
         timeout,
+        batch,
     })
 }
 
@@ -1162,6 +1188,7 @@ args = [1, 2]
 command = "dirsql-plugin-embeddings worker"
 deterministic = true
 timeout = "600s"
+batch = 64
 "#;
         let config = load_config_str(toml).unwrap();
         assert_eq!(
@@ -1172,6 +1199,7 @@ timeout = "600s"
                 command: "dirsql-plugin-embeddings worker".to_string(),
                 deterministic: true,
                 timeout: Some(Duration::from_secs(600)),
+                batch: Some(64),
             }]
         );
     }
@@ -1187,6 +1215,36 @@ command = "worker"
         let config = load_config_str(toml).unwrap();
         assert!(!config.functions[0].deterministic);
         assert!(config.functions[0].timeout.is_none());
+        assert!(config.functions[0].batch.is_none());
+    }
+
+    /// `batch = 0` would send empty requests, a negative cap means nothing,
+    /// and a string is not a count; each is the one actionable error.
+    #[test]
+    fn function_batch_rejects_anything_but_a_positive_integer() {
+        for value in ["0", "-4", "\"many\"", "2.5"] {
+            let toml = format!(
+                r#"
+[[dirsql.function]]
+name = "f"
+args = [1]
+command = "worker"
+batch = {value}
+"#
+            );
+            let err = load_config_str(&toml).unwrap_err();
+            match &err {
+                ConfigError::InvalidFunctionBatch { name, value: got } => {
+                    assert_eq!(name, "f");
+                    assert_eq!(got, value);
+                }
+                other => panic!("batch = {value}: expected InvalidFunctionBatch, got {other:?}"),
+            }
+            assert_eq!(
+                err.to_string(),
+                format!("[[dirsql.function]] 'f': 'batch' must be a positive integer, got {value}")
+            );
+        }
     }
 
     #[test]