dirsql 0.4.54__tar.gz → 0.4.56__tar.gz

{dirsql-0.4.54 → dirsql-0.4.56}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.54"
+version = "0.4.56"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -592,6 +592,7 @@ name = "dirsql-napi"
 version = "0.1.0"
 dependencies = [
  "dirsql",
+ "libc",
  "napi",
  "napi-build",
  "napi-derive",
@@ -599,7 +600,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.54"
+version = "0.4.56"
 dependencies = [
  "dirsql",
  "pyo3",
@@ -2451,6 +2452,7 @@ version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
+ "indexmap",
  "itoa",
  "memchr",
  "serde",

{dirsql-0.4.54 → dirsql-0.4.56}/Cargo.toml

@@ -16,7 +16,9 @@ repository = "https://github.com/thekevinscott/dirsql"
 [workspace.dependencies]
 dirsql = { path = "packages/rust" }
 serde = { version = "1", features = ["derive"] }
-serde_json = "1"
+# `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"] }
 regex = "1"
 thiserror = "2"
 tokio = { version = "1", features = ["rt", "sync"] }

{dirsql-0.4.54 → dirsql-0.4.56}/PKG-INFO

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

{dirsql-0.4.54 → dirsql-0.4.56}/docs/.vitepress/config.ts

@@ -3,7 +3,7 @@ import { defineConfig } from 'vitepress'
 export default defineConfig({
   title: 'dirsql',
   description: 'Ephemeral SQL index over a local directory. Watches a filesystem, ingests structured files into an ephemeral SQLite database, and exposes a SQL query interface.',
-  base: '/dirsql/',
+  base: '/',
 
   // Vite blocks dev-server requests whose Host header isn't allowlisted, so
   // `pnpm dev --host` reached by a network hostname (e.g. a Tailscale

{dirsql-0.4.54 → dirsql-0.4.56}/docs/AGENTS.md

@@ -14,7 +14,7 @@ pnpm install
 pnpm dev
 ```
 
-This starts a local dev server (default: `http://localhost:5173/dirsql/`). The site hot-reloads on file changes.
+This starts a local dev server (default: `http://localhost:5173/`). The site hot-reloads on file changes.
 
 ## Building
 
@@ -94,4 +94,4 @@ Working rules:
 - Use VitePress [code group](https://vitepress.dev/guide/markdown#code-groups) syntax (`::: code-group`) for multi-language examples with `Python`, `Rust`, and `TypeScript` tabs
 - Internal links use relative paths (e.g., `./howto/define-tables.md`)
 - The VitePress config is at `docs/.vitepress/config.ts`
-- The site is deployed under the `/dirsql/` base path
+- The site is deployed at the root of `dirsql.dev`

{dirsql-0.4.54 → dirsql-0.4.56}/docs/reference/sdk.md

@@ -239,6 +239,25 @@ than `Number.MAX_SAFE_INTEGER`, 2^53 − 1) cannot be represented as a JS
 than return a rounded value. Python's `int` is unbounded, so it always
 round-trips.
 
+### `queryOrdered`
+
+::: code-group
+
+```typescript [TypeScript]
+await db.queryOrdered(sql: string) -> { columns: string[]; rows: Record<string, unknown>[] }
+```
+
+```rust [Rust]
+db.query_ordered(sql: &str) -> Result<QueryResult>   // QueryResult { columns, rows }
+```
+
+:::
+
+Runs `query` and also returns the column names in the order the SELECT list
+names them. Use it to render columns in the order the caller asked for: a
+row's keys do not carry that order. In TypeScript, object keys that look like
+integers always enumerate first.
+
 ### `watch`
 
 ::: code-group

{dirsql-0.4.54 → dirsql-0.4.56}/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.54"
+version = "0.4.56"
 # 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.54 → dirsql-0.4.56}/packages/python/docs/.vitepress/config.ts

@@ -3,7 +3,7 @@ import { defineConfig } from 'vitepress'
 export default defineConfig({
   title: 'dirsql',
   description: 'Ephemeral SQL index over a local directory. Watches a filesystem, ingests structured files into an ephemeral SQLite database, and exposes a SQL query interface.',
-  base: '/dirsql/',
+  base: '/',
 
   // Vite blocks dev-server requests whose Host header isn't allowlisted, so
   // `pnpm dev --host` reached by a network hostname (e.g. a Tailscale

{dirsql-0.4.54 → dirsql-0.4.56}/packages/python/docs/AGENTS.md

@@ -14,7 +14,7 @@ pnpm install
 pnpm dev
 ```
 
-This starts a local dev server (default: `http://localhost:5173/dirsql/`). The site hot-reloads on file changes.
+This starts a local dev server (default: `http://localhost:5173/`). The site hot-reloads on file changes.
 
 ## Building
 
@@ -94,4 +94,4 @@ Working rules:
 - Use VitePress [code group](https://vitepress.dev/guide/markdown#code-groups) syntax (`::: code-group`) for multi-language examples with `Python`, `Rust`, and `TypeScript` tabs
 - Internal links use relative paths (e.g., `./howto/define-tables.md`)
 - The VitePress config is at `docs/.vitepress/config.ts`
-- The site is deployed under the `/dirsql/` base path
+- The site is deployed at the root of `dirsql.dev`

{dirsql-0.4.54/packages/rust → dirsql-0.4.56/packages/python}/docs/reference/sdk.md

@@ -239,6 +239,25 @@ than `Number.MAX_SAFE_INTEGER`, 2^53 − 1) cannot be represented as a JS
 than return a rounded value. Python's `int` is unbounded, so it always
 round-trips.
 
+### `queryOrdered`
+
+::: code-group
+
+```typescript [TypeScript]
+await db.queryOrdered(sql: string) -> { columns: string[]; rows: Record<string, unknown>[] }
+```
+
+```rust [Rust]
+db.query_ordered(sql: &str) -> Result<QueryResult>   // QueryResult { columns, rows }
+```
+
+:::
+
+Runs `query` and also returns the column names in the order the SELECT list
+names them. Use it to render columns in the order the caller asked for: a
+row's keys do not carry that order. In TypeScript, object keys that look like
+integers always enumerate first.
+
 ### `watch`
 
 ::: code-group

dirsql-0.4.56/packages/python/e2e-attestations/claude-1170-projection-order.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790181270,
+  "exit_code": 0,
+  "commit": "010d9772867fcb1e1b56ce4a77eb8b0223b0870a",
+  "branch": "claude/1170-projection-order"
+}

dirsql-0.4.56/packages/python/e2e-attestations/claude-1172-on-file-path.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790250389,
+  "exit_code": 0,
+  "commit": "b36c850be9c0cd4b06992b42fe2c689d38783757",
+  "branch": "claude/1172-on-file-path"
+}

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

{dirsql-0.4.54/packages/python → dirsql-0.4.56/packages/rust}/docs/reference/sdk.md

@@ -239,6 +239,25 @@ than `Number.MAX_SAFE_INTEGER`, 2^53 − 1) cannot be represented as a JS
 than return a rounded value. Python's `int` is unbounded, so it always
 round-trips.
 
+### `queryOrdered`
+
+::: code-group
+
+```typescript [TypeScript]
+await db.queryOrdered(sql: string) -> { columns: string[]; rows: Record<string, unknown>[] }
+```
+
+```rust [Rust]
+db.query_ordered(sql: &str) -> Result<QueryResult>   // QueryResult { columns, rows }
+```
+
+:::
+
+Runs `query` and also returns the column names in the order the SELECT list
+names them. Use it to render columns in the order the caller asked for: a
+row's keys do not carry that order. In TypeScript, object keys that look like
+integers always enumerate first.
+
 ### `watch`
 
 ::: code-group

{dirsql-0.4.54 → dirsql-0.4.56}/packages/rust/src/cli/execute.rs

@@ -15,7 +15,7 @@ use serde::Deserialize;
 use serde_json::Value;
 
 use super::AppState;
-use super::serialize::rows_to_json;
+use super::serialize::result_to_json;
 use crate::{DirSQL, DirSqlError};
 
 /// Why a query failed, classified independently of transport. The HTTP
@@ -66,10 +66,14 @@ pub async fn execute_query(
 
     let db = require_ready(state)?;
 
-    let join = run_bounded(timeout, tokio::task::spawn_blocking(move || db.query(&sql))).await?;
+    let join = run_bounded(
+        timeout,
+        tokio::task::spawn_blocking(move || db.query_ordered(&sql)),
+    )
+    .await?;
 
     match join {
-        Ok(Ok(rows)) => Ok(Value::Array(rows_to_json(&rows))),
+        Ok(Ok(result)) => Ok(Value::Array(result_to_json(&result))),
         Ok(Err(err)) => Err(classify_query_error(err)),
         Err(join_err) => Err(QueryFailure::Internal(join_err.to_string())),
     }

{dirsql-0.4.54 → dirsql-0.4.56}/packages/rust/src/cli/serialize.rs

@@ -2,13 +2,29 @@
 
 use serde_json::{Map, Value};
 
-use crate::Row;
 use crate::db::Value as CellValue;
 use crate::differ::RowEvent;
 use crate::row_event_flat::flatten_row_event;
+use crate::{QueryResult, Row};
+
+/// Serialize a query result, each object keyed in projection order. Row events
+/// carry no projection, so they keep going through [`row_to_json`].
+pub(super) fn result_to_json(result: &QueryResult) -> Vec<Value> {
+    result
+        .rows
+        .iter()
+        .map(|row| ordered_row_to_json(&result.columns, row))
+        .collect()
+}
 
-pub(super) fn rows_to_json(rows: &[Row]) -> Vec<Value> {
-    rows.iter().map(row_to_json).collect()
+fn ordered_row_to_json(columns: &[String], row: &Row) -> Value {
+    let mut map = Map::with_capacity(columns.len());
+    for column in columns {
+        if let Some(value) = row.get(column) {
+            map.insert(column.clone(), cell_to_json(value));
+        }
+    }
+    Value::Object(map)
 }
 
 pub(super) fn row_to_json(row: &Row) -> Value {
@@ -75,6 +91,35 @@ mod tests {
         assert_eq!(json.get("count").and_then(Value::as_i64), Some(3));
     }
 
+    #[test]
+    fn a_result_serializes_its_rows_in_projection_order() {
+        let mut row: Row = HashMap::new();
+        row.insert("title".into(), CellValue::Text("Hello".into()));
+        row.insert("count".into(), CellValue::Integer(3));
+        let result = QueryResult {
+            columns: vec!["count".into(), "title".into()],
+            rows: vec![row],
+        };
+
+        let json = result_to_json(&result);
+
+        assert_eq!(json[0].to_string(), r#"{"count":3,"title":"Hello"}"#);
+    }
+
+    #[test]
+    fn a_column_no_row_key_matches_is_left_out() {
+        let mut row: Row = HashMap::new();
+        row.insert("title".into(), CellValue::Text("Hello".into()));
+        let result = QueryResult {
+            columns: vec!["title".into(), "title".into()],
+            rows: vec![row],
+        };
+
+        let json = result_to_json(&result);
+
+        assert_eq!(json[0].to_string(), r#"{"title":"Hello"}"#);
+    }
+
     #[test]
     fn insert_event_emits_expected_shape() {
         let mut row: Row = HashMap::new();

{dirsql-0.4.54 → dirsql-0.4.56}/packages/rust/src/cli/table.rs

@@ -11,7 +11,7 @@
 //! swallowing the table; laying the table out to the terminal's width, and
 //! paging a long result, are both out of scope.
 
-use std::collections::BTreeSet;
+use std::collections::HashSet;
 
 use serde_json::Value;
 
@@ -53,16 +53,22 @@ pub(super) fn render(rows: &[Value]) -> String {
     out
 }
 
-/// Every column any row carries. Rows are JSON objects, so the keys arrive
-/// sorted and stay in step with the JSON rendering of the same result.
+/// Every column any row carries, first seen first. Rows are JSON objects
+/// serialized in projection order, so that is the order the SELECT list asked
+/// for -- and the same order the JSON rendering of this result prints.
 fn columns(rows: &[Value]) -> Vec<String> {
-    let mut names = BTreeSet::new();
+    let mut seen = HashSet::new();
+    let mut names = Vec::new();
     for row in rows {
         if let Value::Object(map) = row {
-            names.extend(map.keys().cloned());
+            for key in map.keys() {
+                if seen.insert(key.clone()) {
+                    names.push(key.clone());
+                }
+            }
         }
     }
-    names.into_iter().collect()
+    names
 }
 
 /// One row's cells, in column order. A row missing a column renders it as
@@ -242,6 +248,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn the_header_keeps_the_order_the_row_carries() {
+        // Rows arrive serialized in projection order; re-sorting them here is
+        // what made `SELECT size, basename` print `basename  size`.
+        let table = rendered([row([
+            ("size", Value::from(6)),
+            ("basename", Value::from("a.md")),
+        ])]);
+
+        assert!(table.starts_with("size  basename\n"), "{table:?}");
+    }
+
+    #[test]
+    fn a_later_rows_new_columns_come_after_the_earlier_ones() {
+        let table = rendered([row([("b", Value::from(1))]), row([("a", Value::from(2))])]);
+
+        assert!(table.starts_with("b     a\n"), "{table:?}");
+    }
+
     #[test]
     fn every_column_any_row_carries_is_shown() {
         // A ragged result must not silently drop the columns only some rows

{dirsql-0.4.54 → dirsql-0.4.56}/packages/rust/src/command.rs

@@ -26,7 +26,7 @@
 //! - **Errors.** A non-zero exit is a failure carrying the tail of stderr.
 
 use std::io::{Read, Write};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 /// A named placeholder substituted into a command's argv.
@@ -66,14 +66,22 @@ pub enum CommandError {
     #[error("invalid command template: {0:?}")]
     InvalidCommand(String),
 
-    /// The child could not be spawned (e.g. the program was not found).
-    #[error("failed to spawn `{command}`: {source}")]
+    /// The child could not be spawned.
+    #[error("failed to spawn `{program}`: {source}")]
     Spawn {
-        command: String,
+        program: String,
         #[source]
         source: std::io::Error,
     },
 
+    /// A program named without a `/` was not found on `$PATH`. `local` is the
+    /// file of that name in the child's cwd, which a bare name never reaches.
+    #[error("failed to spawn `{program}`: not found on $PATH{}", local_hint(.program, .local.as_deref()))]
+    NotOnPath {
+        program: String,
+        local: Option<PathBuf>,
+    },
+
     /// The child exited with a non-zero status. `code` is the exit code, or
     /// `"signal"` when the child was terminated by a signal.
     #[error("command `{command}` failed (exit {code}): {stderr_tail}")]
@@ -121,10 +129,9 @@ pub fn run_command(
             Stdio::null()
         });
 
-    let mut child = cmd.spawn().map_err(|source| CommandError::Spawn {
-        command: command.to_string(),
-        source,
-    })?;
+    let mut child = cmd
+        .spawn()
+        .map_err(|source| spawn_error(&argv[0], source, cwd))?;
 
     // Feed stdin and drain stdout/stderr on their own threads. Draining the
     // output pipes concurrently is required: a child that writes more than a
@@ -186,6 +193,37 @@ pub fn run_command(
     }
 }
 
+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() {
+        return CommandError::Spawn {
+            program: program.to_string(),
+            source,
+        };
+    }
+    let candidate = cwd.join(program);
+    CommandError::NotOnPath {
+        program: program.to_string(),
+        local: candidate.is_file().then_some(candidate),
+    }
+}
+
+/// A `NotFound` for a name without a `/` means the `$PATH` search came up
+/// empty (`execvp` semantics); with a `/` the name was a path.
+fn searched_path(program: &str, kind: std::io::ErrorKind) -> bool {
+    kind == std::io::ErrorKind::NotFound && !program.contains('/')
+}
+
+fn local_hint(program: &str, local: Option<&Path>) -> String {
+    match local {
+        Some(path) => format!(
+            ". Names without a `/` are resolved against $PATH; use `./{program}` to run `{}`",
+            path.display()
+        ),
+        None => String::new(),
+    }
+}
+
 /// Split a command template into argv (shell-like quoting, no shell) and
 /// substitute placeholders into whole tokens.
 pub(crate) fn build_argv(
@@ -444,8 +482,65 @@ mod tests {
     }
 
     #[test]
-    fn run_command_reports_spawn_failure_for_a_missing_program() {
+    fn run_command_reports_a_bare_missing_program_as_not_on_path() {
         let err = run_command("definitely-not-a-real-binary-xyzzy", &[], &cwd(), None).unwrap_err();
+        assert!(
+            matches!(err, CommandError::NotOnPath { local: None, .. }),
+            "got: {err:?}"
+        );
+    }
+
+    #[test]
+    fn run_command_reports_a_missing_path_as_a_plain_spawn_error() {
+        let err =
+            run_command("./definitely-not-a-real-binary-xyzzy", &[], &cwd(), None).unwrap_err();
         assert!(matches!(err, CommandError::Spawn { .. }), "got: {err:?}");
     }
+
+    #[test]
+    fn a_bare_not_found_name_searched_path() {
+        assert!(searched_path("extract.py", std::io::ErrorKind::NotFound));
+    }
+
+    #[test]
+    fn a_name_with_a_slash_did_not_search_path() {
+        assert!(!searched_path("./extract.py", std::io::ErrorKind::NotFound));
+        assert!(!searched_path(
+            "bin/extract.py",
+            std::io::ErrorKind::NotFound
+        ));
+    }
+
+    #[test]
+    fn a_non_not_found_error_did_not_search_path() {
+        assert!(!searched_path(
+            "extract.py",
+            std::io::ErrorKind::PermissionDenied
+        ));
+    }
+
+    #[test]
+    fn not_on_path_without_a_local_file_offers_no_hint() {
+        let err = CommandError::NotOnPath {
+            program: "extract.py".to_string(),
+            local: None,
+        };
+        assert_eq!(
+            err.to_string(),
+            "failed to spawn `extract.py`: not found on $PATH"
+        );
+    }
+
+    #[test]
+    fn not_on_path_with_a_local_file_offers_the_dot_slash_form() {
+        let err = CommandError::NotOnPath {
+            program: "extract.py".to_string(),
+            local: Some(PathBuf::from("/notes/extract.py")),
+        };
+        assert_eq!(
+            err.to_string(),
+            "failed to spawn `extract.py`: not found on $PATH. Names without a `/` are \
+             resolved against $PATH; use `./extract.py` to run `/notes/extract.py`"
+        );
+    }
 }

{dirsql-0.4.54 → dirsql-0.4.56}/packages/rust/src/db.rs

@@ -244,6 +244,13 @@ pub fn ensure_internal_rows_table(conn: &Connection) -> rusqlite::Result<()> {
     )
 }
 
+/// One query's rows plus the column order the SELECT list asked for.
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueryResult {
+    pub columns: Vec<String>,
+    pub rows: Vec<HashMap<String, Value>>,
+}
+
 pub struct Db {
     conn: Connection,
     /// The directory a path-table's glob is resolved against. `None` disables
@@ -714,6 +721,14 @@ impl Db {
     /// internal writes (`insert_row`, delete-by-file, persist), which never go
     /// through `query()`, are unaffected.
     pub fn query(&self, sql: &str) -> Result<Vec<HashMap<String, Value>>> {
+        self.query_ordered(sql).map(|result| result.rows)
+    }
+
+    /// [`query`](Self::query), plus the projection order. A row is a
+    /// `HashMap`, so the order the SELECT list asked for survives only in
+    /// [`QueryResult::columns`]; a renderer that re-derives its columns from
+    /// row keys prints them alphabetically instead.
+    pub fn query_ordered(&self, sql: &str) -> Result<QueryResult> {
         // Bracket the whole statement, prepare included: a worker-backed
         // function called on every row makes this the slowest thing dirsql
         // does, and the guard is what erases the counter before the caller
@@ -757,7 +772,10 @@ impl Db {
         for row in rows {
             results.push(row?);
         }
-        Ok(results)
+        Ok(QueryResult {
+            columns: column_names,
+            rows: results,
+        })
     }
 
     /// Prepare `sql` with the internal-table / ATTACH authorizer installed for
@@ -1026,6 +1044,40 @@ mod tests {
         assert!(!rows[0].contains_key("_dirsql_row_index"));
     }
 
+    #[test]
+    fn query_ordered_reports_the_select_list_order() {
+        let db = Db::new().unwrap();
+        db.create_table("docs", "CREATE TABLE docs (title TEXT, draft INTEGER)")
+            .unwrap();
+
+        let result = db.query_ordered("SELECT draft, title FROM docs").unwrap();
+
+        assert_eq!(
+            result.columns,
+            vec!["draft".to_string(), "title".to_string()]
+        );
+    }
+
+    #[test]
+    fn query_ordered_carries_the_same_rows_query_returns() {
+        let db = Db::new().unwrap();
+        db.create_table("docs", "CREATE TABLE docs (title TEXT, draft INTEGER)")
+            .unwrap();
+        let row = HashMap::from([
+            ("title".into(), Value::Text("Hello".into())),
+            ("draft".into(), Value::Integer(0)),
+        ]);
+        db.insert_row("docs", &row, "docs/hello.md", 0).unwrap();
+
+        let result = db.query_ordered("SELECT title, draft FROM docs").unwrap();
+
+        assert_eq!(
+            result.rows,
+            db.query("SELECT title, draft FROM docs").unwrap()
+        );
+        assert_eq!(result.rows[0]["title"], Value::Text("Hello".into()));
+    }
+
     #[test]
     fn pragma_table_info_matches_user_ddl_exactly() {
         let db = Db::new().unwrap();

{dirsql-0.4.54 → dirsql-0.4.56}/packages/rust/src/lib.rs

@@ -77,7 +77,7 @@ use std::time::Duration;
 use thiserror::Error;
 
 pub use crate::config::ExtensionSpec as Extension;
-pub use crate::db::{DbError, Value};
+pub use crate::db::{DbError, QueryResult, Value};
 pub use crate::differ::RowEvent;
 #[doc(hidden)]
 pub use crate::row_event_flat::{FlatRowEvent, flatten_row_event};
@@ -404,8 +404,15 @@ impl DirSQL {
     /// keeps the ephemeral index consistent with the on-disk files that back
     /// it: mutations only happen through the watcher/indexer pipeline.
     pub fn query(&self, sql: &str) -> Result<Vec<Row>> {
+        self.query_ordered(sql).map(|result| result.rows)
+    }
+
+    /// [`query`](Self::query), plus the projection order in
+    /// [`QueryResult::columns`]. A [`Row`] is a `HashMap`, so a caller that
+    /// renders columns in the order the user asked for needs this instead.
+    pub fn query_ordered(&self, sql: &str) -> Result<QueryResult> {
         let db = self.inner.db.lock().map_err(DirSqlError::lock)?;
-        db.query(sql).map_err(map_db_error)
+        db.query_ordered(sql).map_err(map_db_error)
     }
 
     /// Lazily create the filesystem watcher. Idempotent; subsequent calls are