dirsql 0.4.130__tar.gz → 0.4.131__tar.gz

{dirsql-0.4.130 → dirsql-0.4.131}/Cargo.lock

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

{dirsql-0.4.130 → dirsql-0.4.131}/PKG-INFO

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

{dirsql-0.4.130 → dirsql-0.4.131}/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.130"
+version = "0.4.131"
 # 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.131/packages/python/e2e-attestations/bot-1475-prefix-speed-1016.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_gitignore_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_node_modules_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_symlink_test.py tests/e2e/stat_speed_test.py tests/e2e/frontmatter_parse_speed_test.py tests/e2e/jsonl_parse_speed_test.py tests/e2e/query_contract_test.py tests/e2e/fanout_test.py tests/e2e/repl_interactive_test.py tests/e2e/server_speed_test.py -q",
+  "ran_at": 1793763290,
+  "exit_code": 0,
+  "commit": "80d1da9e6e85a68d69a48840dc58f00a09775b11",
+  "branch": "bot/1475-prefix-speed-1016"
+}

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

{dirsql-0.4.130 → dirsql-0.4.131}/packages/rust/src/cli/run.rs

@@ -329,7 +329,13 @@ pub fn run_cli(argv: Vec<String>) -> i32 {
         }
     };
 
-    let runtime = match tokio::runtime::Runtime::new() {
+    let runtime = match if serves(&cli) {
+        tokio::runtime::Runtime::new()
+    } else {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+    } {
         Ok(runtime) => runtime,
         Err(err) => {
             eprintln!("dirsql: failed to start the async runtime: {err}");
@@ -352,6 +358,13 @@ pub fn run_cli(argv: Vec<String>) -> i32 {
     i32::from(code)
 }
 
+/// Whether `cli` keeps serving, as the server and the REPL do, and so wants a
+/// runtime with a worker per core; a one-shot command waits on one thing at a
+/// time, and starting and stopping those workers is a cost it would only pay.
+fn serves(cli: &Cli) -> bool {
+    matches!(cli.command, Some(Command::Server(_))) || (cli.command.is_none() && cli.sql.is_none())
+}
+
 /// The default (no-subcommand) behavior. With SQL, run it as a one-shot query,
 /// exactly as `dirsql query "<sql>"` does. With no SQL, read statements until
 /// EOF instead: bare `dirsql` is a REPL over the current directory, prompted
@@ -679,6 +692,24 @@ mod tests {
         assert_eq!(query_body("   "), r#"{"sql":"   "}"#);
     }
 
+    #[test]
+    fn the_server_and_the_repl_serve() {
+        let serving =
+            [&["dirsql", "server"][..], &["dirsql"]].map(|argv| serves(&Cli::parse_from(argv)));
+        assert_eq!(serving, [true, true]);
+    }
+
+    #[test]
+    fn one_shot_commands_do_not_serve() {
+        let serving = [
+            &["dirsql", "query", "SELECT 1"][..],
+            &["dirsql", "SELECT 1"],
+            &["dirsql", "context"],
+        ]
+        .map(|argv| serves(&Cli::parse_from(argv)));
+        assert_eq!(serving, [false, false, false]);
+    }
+
     fn query_args(argv: &[&str]) -> QueryArgs {
         match Cli::parse_from(argv).command {
             Some(Command::Query(args)) => args,

{dirsql-0.4.130 → dirsql-0.4.131}/packages/rust/src/tree_walk.rs

@@ -130,6 +130,8 @@ struct Shared<'e, D, L> {
     open: Mutex<Open<D, L>>,
     found_dir: Condvar,
     found: AtomicUsize,
+    /// Threads started on the walk, the calling thread among them.
+    hired: AtomicUsize,
     explore: &'e (dyn Fn(D) -> Vec<Step<D, L>> + Sync),
 }
 
@@ -147,6 +149,7 @@ pub(crate) fn walk_in_order<D: Send, L: Send>(
         }),
         found_dir: Condvar::new(),
         found: AtomicUsize::new(1),
+        hired: AtomicUsize::new(1),
         explore,
     };
     thread::scope(|scope| {
@@ -159,9 +162,7 @@ pub(crate) fn walk_in_order<D: Send, L: Send>(
                     if !spawned && shared.found.load(Ordering::Relaxed) >= PARALLEL_DIRS {
                         spawned = true;
                         let workers = thread::available_parallelism().map_or(1, usize::from);
-                        for _ in 1..workers {
-                            scope.spawn(|| shared.work());
-                        }
+                        hire(scope, &shared, workers);
                     }
                     stack.push(shared.obtain(&slot).into_iter());
                 }
@@ -179,6 +180,25 @@ fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
     mutex.lock().expect("exploring a directory does not panic")
 }
 
+/// Start workers until `workers` threads are on the walk, as a tree: each
+/// worker starts up to two more before it explores, since spawning a thread
+/// takes tens of microseconds and the walk hands out nothing while it spawns.
+/// The count only rises, so however the tree branches it ends.
+fn hire<'scope, D: Send, L: Send>(
+    scope: &'scope thread::Scope<'scope, '_>,
+    shared: &'scope Shared<'_, D, L>,
+    workers: usize,
+) {
+    for _ in 0..2 {
+        if shared.hired.fetch_add(1, Ordering::Relaxed) < workers {
+            scope.spawn(move || {
+                hire(scope, shared, workers);
+                shared.work();
+            });
+        }
+    }
+}
+
 impl<D, L> Shared<'_, D, L> {
     fn open_lock(&self) -> MutexGuard<'_, Open<D, L>> {
         lock(&self.open)
@@ -392,6 +412,7 @@ mod tests {
             }),
             found_dir: Condvar::new(),
             found: AtomicUsize::new(0),
+            hired: AtomicUsize::new(1),
             explore: &explore,
         };
         assert!(