queryview 0.0.2__tar.gz → 0.0.4__tar.gz

{queryview-0.0.2 → queryview-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: queryview
-Version: 0.0.2
+Version: 0.0.4
 Summary: QueryView: FastAPI + SQLModel backend and React SPA over the ClickHouse HTTP interface
 Project-URL: Homepage, https://github.com/kolodkin/queryview
 Project-URL: Repository, https://github.com/kolodkin/queryview
@@ -16,6 +16,7 @@ Requires-Dist: duckdb>=1.0
 Requires-Dist: fastapi>=0.110
 Requires-Dist: httpx>=0.27
 Requires-Dist: mcp<2,>=1.9
+Requires-Dist: platformdirs>=4
 Requires-Dist: pyyaml>=6
 Requires-Dist: sqlalchemy[asyncio]>=2.0
 Requires-Dist: sqlmodel>=0.0.16
@@ -46,7 +47,9 @@ docker run -p 8000:8000 ghcr.io/kolodkin/queryview:latest
 ```
 
 To serve on a different host port, remap it (the container keeps listening on
-8000, which its healthcheck probes): `docker run -p 9000:8000 ...`.
+8000, which its healthcheck probes): `docker run -p 9000:8000 ...`. QueryView
+expects to be reached from localhost only, so prefer binding the published port
+to loopback: `docker run -p 127.0.0.1:8000:8000 ...`.
 
 State (the SQLite DB and its encryption key) lives in `/home/queryview`; mount a
 volume there to persist it across containers:
@@ -154,14 +157,34 @@ An installed wheel serves the bundled UI by default — see
 ## MCP server
 
 The backend mounts a FastMCP server (Streamable HTTP) at
-`http://localhost:8000/mcp`. There is nothing extra to start — it runs inside
-the server process (`uvx queryview`, `npm run dev`, ...). Hook up an MCP client,
-e.g.:
+`http://localhost:8000/mcp/`. There is nothing extra to start — it runs inside
+the server process (`uvx queryview`, `npm run dev`, ...). Registering the client
+is a separate, one-time step on the machine running the agent: an HTTP MCP
+server can't install itself into someone else's client.
 
 ```bash
-claude mcp add --transport http queryview http://localhost:8000/mcp
+claude mcp add --transport http queryview http://localhost:8000/mcp/
 ```
 
+Three things to get right:
+
+- **Prefer the trailing slash.** The mount serves `/mcp/`. The slashless
+  `/mcp` also works — it 307-redirects — but registering the canonical path
+  skips a round trip on every call.
+- **Match the port.** The URL must point at the port QueryView actually
+  listens on — `--port 9000` means `http://localhost:9000/mcp/`, and
+  `docker run -p 9000:8000` means the *host* port, `9000`, not the container's
+  `8000`.
+- **Start QueryView first.** The client dials this URL when it starts; if
+  nothing is listening it reports a connection error and stays failed until you
+  reconnect it.
+
+QueryView is a **local, single-user tool**: it assumes it is reachable only from
+localhost. `/mcp/` is unauthenticated, and its tools can query every configured
+connection and rewrite workspace git state, so don't publish the port. Bind the
+container to loopback — `docker run -p 127.0.0.1:8000:8000 ...` — since a plain
+`-p 8000:8000` listens on all interfaces.
+
 Tools: `run_query` (read-only SQL, rows returned to the agent), `push_query`
 and `push_dashboard` (fill a live browser session), `list_queries` /
 `list_dashboards`, and `git_store` / `git_history` / `git_restore` (workspace
@@ -178,6 +201,10 @@ The single-page prompt UI is described in [docs/queryview.md](docs/queryview.md)
 connecting (`new <type>` / `connect <name>`), SQLite persistence, and session
 auto-connect are specified in [docs/connect.md](docs/connect.md).
 
-Connections are stored in SQLite (`backend/queryview.db`, override with
-`DB_PATH`); the backend writes that file and a local password-encryption key
-(`backend/queryview.db.key`, override with `DB_KEY_PATH`).
+Connections are stored in SQLite. The default location is the platform's
+user-data directory — `$XDG_DATA_HOME/queryview/queryview.db` (i.e.
+`~/.local/share/queryview/`) on Linux, `~/Library/Application Support/queryview/`
+on macOS, `%LOCALAPPDATA%\queryview\` on Windows — overridable with `DB_PATH`.
+Alongside it the backend writes a local password-encryption key
+(`<db>.key`, override with `DB_KEY_PATH`) and the workspace git-sync clones
+(`<db>.gitsync/`, override with `GIT_SYNC_DIR`).

{queryview-0.0.2 → queryview-0.0.4}/README.md

@@ -22,7 +22,9 @@ docker run -p 8000:8000 ghcr.io/kolodkin/queryview:latest
 ```
 
 To serve on a different host port, remap it (the container keeps listening on
-8000, which its healthcheck probes): `docker run -p 9000:8000 ...`.
+8000, which its healthcheck probes): `docker run -p 9000:8000 ...`. QueryView
+expects to be reached from localhost only, so prefer binding the published port
+to loopback: `docker run -p 127.0.0.1:8000:8000 ...`.
 
 State (the SQLite DB and its encryption key) lives in `/home/queryview`; mount a
 volume there to persist it across containers:
@@ -130,14 +132,34 @@ An installed wheel serves the bundled UI by default — see
 ## MCP server
 
 The backend mounts a FastMCP server (Streamable HTTP) at
-`http://localhost:8000/mcp`. There is nothing extra to start — it runs inside
-the server process (`uvx queryview`, `npm run dev`, ...). Hook up an MCP client,
-e.g.:
+`http://localhost:8000/mcp/`. There is nothing extra to start — it runs inside
+the server process (`uvx queryview`, `npm run dev`, ...). Registering the client
+is a separate, one-time step on the machine running the agent: an HTTP MCP
+server can't install itself into someone else's client.
 
 ```bash
-claude mcp add --transport http queryview http://localhost:8000/mcp
+claude mcp add --transport http queryview http://localhost:8000/mcp/
 ```
 
+Three things to get right:
+
+- **Prefer the trailing slash.** The mount serves `/mcp/`. The slashless
+  `/mcp` also works — it 307-redirects — but registering the canonical path
+  skips a round trip on every call.
+- **Match the port.** The URL must point at the port QueryView actually
+  listens on — `--port 9000` means `http://localhost:9000/mcp/`, and
+  `docker run -p 9000:8000` means the *host* port, `9000`, not the container's
+  `8000`.
+- **Start QueryView first.** The client dials this URL when it starts; if
+  nothing is listening it reports a connection error and stays failed until you
+  reconnect it.
+
+QueryView is a **local, single-user tool**: it assumes it is reachable only from
+localhost. `/mcp/` is unauthenticated, and its tools can query every configured
+connection and rewrite workspace git state, so don't publish the port. Bind the
+container to loopback — `docker run -p 127.0.0.1:8000:8000 ...` — since a plain
+`-p 8000:8000` listens on all interfaces.
+
 Tools: `run_query` (read-only SQL, rows returned to the agent), `push_query`
 and `push_dashboard` (fill a live browser session), `list_queries` /
 `list_dashboards`, and `git_store` / `git_history` / `git_restore` (workspace
@@ -154,6 +176,10 @@ The single-page prompt UI is described in [docs/queryview.md](docs/queryview.md)
 connecting (`new <type>` / `connect <name>`), SQLite persistence, and session
 auto-connect are specified in [docs/connect.md](docs/connect.md).
 
-Connections are stored in SQLite (`backend/queryview.db`, override with
-`DB_PATH`); the backend writes that file and a local password-encryption key
-(`backend/queryview.db.key`, override with `DB_KEY_PATH`).
+Connections are stored in SQLite. The default location is the platform's
+user-data directory — `$XDG_DATA_HOME/queryview/queryview.db` (i.e.
+`~/.local/share/queryview/`) on Linux, `~/Library/Application Support/queryview/`
+on macOS, `%LOCALAPPDATA%\queryview\` on Windows — overridable with `DB_PATH`.
+Alongside it the backend writes a local password-encryption key
+(`<db>.key`, override with `DB_KEY_PATH`) and the workspace git-sync clones
+(`<db>.gitsync/`, override with `GIT_SYNC_DIR`).

{queryview-0.0.2 → queryview-0.0.4}/backend/queryview/connect.py

@@ -14,6 +14,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
 
+import platformdirs
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlmodel import Field, SQLModel, col, select
@@ -40,10 +41,14 @@ class Connection(SQLModel, table=True):
 
 
 def _db_path() -> Path:
+    """The SQLite store's path: DB_PATH, else the platform's user-data dir
+    (`$XDG_DATA_HOME/queryview` on Linux, `Application Support` on macOS,
+    `%LOCALAPPDATA%` on Windows). Deliberately not package-relative — that put
+    the DB in site-packages, which is uv's disposable cache under `uvx`."""
     env = os.environ.get("DB_PATH")
     if env:
         return Path(env)
-    return Path(__file__).resolve().parent.parent / "queryview.db"
+    return Path(platformdirs.user_data_dir("queryview")) / "queryview.db"
 
 
 _engine = None
@@ -80,6 +85,9 @@ async def _ensure_schema() -> None:
         return
     from alembic import command
 
+    # SQLite won't create a missing parent, and the user-data dir doesn't exist
+    # on a fresh install; the key file and git-sync clones land here too.
+    _db_path().parent.mkdir(parents=True, exist_ok=True)
     command.upgrade(_alembic_config(), "head")
     _schema_ready = True
 
@@ -414,15 +422,32 @@ async def run_query(
     sql: str,
     limit: int,
     offset: int,
-    fmt: str,
     order_by: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
-    """Run a paginated SQL query against this session's selected database. The
-    driver owns pagination/quoting; `fmt` is the logical 'tsv'/'csv'."""
+    """Run a paginated SQL query against this session's selected database and
+    return `{ok, meta: [{name, type}], data: [[…]]}`. The driver owns
+    pagination/quoting."""
     s, err = await _gated_session(sid)
     if s is None:
         return err  # type: ignore[return-value]
-    r = await DRIVERS[s.type].run_query(s.config, sql, s.database, limit, offset, order_by, fmt)
+    r = await DRIVERS[s.type].run_query(s.config, sql, s.database, limit, offset, order_by)
+    if not r.ok or r.rows is None:
+        return {"ok": False, "message": r.message}
+    return {"ok": True, "meta": [c._asdict() for c in r.rows.meta], "data": r.rows.data}
+
+
+async def export_csv(
+    sid: str,
+    sql: str,
+    limit: int,
+    offset: int,
+    order_by: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """The same page as `run_query`, as CSVWithNames text in `output`."""
+    s, err = await _gated_session(sid)
+    if s is None:
+        return err  # type: ignore[return-value]
+    r = await DRIVERS[s.type].export_csv(s.config, sql, s.database, limit, offset, order_by)
     if not r.ok:
         return {"ok": False, "message": r.value}
     return {"ok": True, "output": r.value}

{queryview-0.0.2 → queryview-0.0.4}/backend/queryview/dashboard_queries.py

@@ -9,27 +9,13 @@ from typing import Any
 
 from .connect import _connection_by_name
 from .drivers import DRIVERS
+from .drivers.base import rows_to_columns
 
 # Row cap per dashboard query (matches /api/clickhouse/query's ceiling), applied
 # as the LIMIT of the subselect wrapping each query.
 DASHBOARD_ROW_CAP = 1000
 
 
-def _parse_tsv_columns(text: str) -> dict[str, list[str]]:
-    """Parse TabSeparatedWithNames into a column-oriented, insertion-ordered dict
-    `{column_name: [values, …]}` (first line = names, rest = rows). Empty -> {}."""
-    if text == "":
-        return {}
-    lines = text.split("\n")
-    names = lines[0].split("\t")
-    cols: dict[str, list[str]] = {name: [] for name in names}
-    for line in lines[1:]:
-        values = line.split("\t")
-        for i, name in enumerate(names):
-            cols[name].append(values[i] if i < len(values) else "")
-    return cols
-
-
 async def run_queries_for_connection(
     name: str,
     queries: dict[str, str],
@@ -39,8 +25,9 @@ async def run_queries_for_connection(
     """Run a dashboard's named queries against a saved connection by name.
     Fail-fast: an unknown connection, no selected database, or the first failing
     query aborts the call. On full success returns {"ok": True, "results": {name:
-    {col: [values, …]}}} — column-oriented, ready for window.queries. `limit`/
-    `offset` page each query (default: the dashboard row cap, from row 0)."""
+    {col: [values, …]}}, "meta": {name: [{name, type}, …]}} — column-oriented,
+    ready for window.queries, values typed as the driver returned them.
+    `limit`/`offset` page each query (default: the dashboard row cap, from row 0)."""
     stored = await _connection_by_name(name)
     if stored is None:
         return {
@@ -58,18 +45,12 @@ async def run_queries_for_connection(
                 "or fully-qualify table names as db.table"
             ),
         }
-    results: dict[str, dict[str, list[str]]] = {}
+    results: dict[str, dict[str, list[Any]]] = {}
+    meta: dict[str, list[dict[str, str]]] = {}
     for qname, sql in queries.items():
-        r = await driver.run_query(
-            stored.config,
-            sql,
-            stored.database,
-            limit=limit,
-            offset=offset,
-            order_by=None,
-            fmt="tsv",
-        )
-        if not r.ok:
-            return {"ok": False, "reason": "query", "message": f"{qname}: {r.value}"}
-        results[qname] = _parse_tsv_columns(r.value)
-    return {"ok": True, "results": results}
+        r = await driver.run_query(stored.config, sql, stored.database, limit=limit, offset=offset, order_by=None)
+        if not r.ok or r.rows is None:
+            return {"ok": False, "reason": "query", "message": f"{qname}: {r.message}"}
+        results[qname] = rows_to_columns(r.rows)
+        meta[qname] = [c._asdict() for c in r.rows.meta]
+    return {"ok": True, "results": results, "meta": meta}

{queryview-0.0.2 → queryview-0.0.4}/backend/queryview/drivers/base.py

@@ -1,16 +1,40 @@
-"""The driver contract (Protocol) plus dialect helpers and the row serializer
-shared by row-returning drivers. No backend/storage concerns here."""
+"""The driver contract (Protocol) plus dialect helpers and the shared result
+contract: typed, JSON-safe rows for the UI and CSV text for download. No
+backend/storage concerns here."""
 
 from __future__ import annotations
 
 import csv
+import datetime as dt
 import io
+import math
+import uuid
+from decimal import Decimal
 from typing import Any, NamedTuple, Protocol, TypeAlias, runtime_checkable
 
 
+class Column(NamedTuple):
+    name: str
+    type: str  # the dialect's own type name (ClickHouse `UInt64`, Postgres `text`, …)
+
+
+class QueryRows(NamedTuple):
+    """A query result in ClickHouse's JSONCompact shape: column metadata plus
+    row-major values that are JSON-safe as-is (see `to_json_value`)."""
+
+    meta: list[Column]
+    data: list[list[Any]]
+
+
 class QueryResult(NamedTuple):
     ok: bool
-    value: str  # serialized rows when ok; an error message otherwise
+    rows: QueryRows | None = None  # set when ok
+    message: str = ""  # set when not ok
+
+
+class TextResult(NamedTuple):
+    ok: bool
+    value: str  # the text when ok; an error message otherwise
 
 
 # A driver's own config object (ChConfig, PgConfig, DuckConfig, …). Opaque to
@@ -56,8 +80,17 @@ class Driver(Protocol):
         limit: int,
         offset: int,
         order_by: list[dict[str, Any]] | None,
-        fmt: str,
     ) -> QueryResult: ...
+    # The same page as run_query, as CSVWithNames text for download.
+    async def export_csv(
+        self,
+        config: DriverConfig,
+        sql: str,
+        database: str | None,
+        limit: int,
+        offset: int,
+        order_by: list[dict[str, Any]] | None,
+    ) -> TextResult: ...
     async def describe_query(
         self,
         config: DriverConfig,
@@ -148,18 +181,53 @@ def wrap_paginated(
     return " ".join(clauses)
 
 
-def serialize_rows(columns: list[str], rows: list[Any], fmt: str) -> str:
-    """Serialize rows to the text contract ClickHouse emits: TabSeparatedWithNames
-    (fmt='tsv') or CSVWithNames (fmt='csv'). None -> empty field. Non-strings are
-    str()-ified. No trailing newline (matches ClickHouse's stripped output)."""
-    if fmt == "csv":
-        buf = io.StringIO()
-        writer = csv.writer(buf, lineterminator="\n")
-        writer.writerow(columns)
-        for row in rows:
-            writer.writerow(["" if v is None else str(v) for v in row])
-        return buf.getvalue().rstrip("\n")
-    lines = ["\t".join(columns)]
+# The largest integer a JS number holds exactly; beyond it values travel as strings.
+_JS_SAFE_INT = 2**53 - 1
+
+
+def to_json_value(v: Any) -> Any:
+    """A JSON-safe value that survives the browser: ints beyond 2^53, Decimals,
+    NaN/Inf, datetimes, UUIDs, and bytes become strings; containers recurse;
+    JSON scalars pass through. Mirrors what ClickHouse's JSONCompact emits
+    with 64-bit integers and decimals quoted, so every driver looks the same."""
+    if v is None or isinstance(v, (bool, str)):
+        return v
+    if isinstance(v, int):
+        return v if -_JS_SAFE_INT <= v <= _JS_SAFE_INT else str(v)
+    if isinstance(v, float):
+        return str(v) if math.isnan(v) or math.isinf(v) else v
+    if isinstance(v, Decimal):
+        return str(v)
+    if isinstance(v, (dt.datetime, dt.date, dt.time)):
+        return v.isoformat()
+    if isinstance(v, uuid.UUID):
+        return str(v)
+    if isinstance(v, (bytes, bytearray)):
+        return bytes(v).decode("utf-8", "replace")
+    if isinstance(v, (list, tuple, set, frozenset)):
+        return [to_json_value(x) for x in v]
+    if isinstance(v, dict):
+        return {str(k): to_json_value(x) for k, x in v.items()}
+    return str(v)
+
+
+def to_csv(columns: list[str], rows: list[Any]) -> str:
+    """CSVWithNames text as ClickHouse emits it: header row, LF line ends, None
+    as an empty field, no trailing newline."""
+    buf = io.StringIO()
+    writer = csv.writer(buf, lineterminator="\n")
+    writer.writerow(columns)
     for row in rows:
-        lines.append("\t".join("" if v is None else str(v) for v in row))
-    return "\n".join(lines)
+        writer.writerow(["" if v is None else str(v) for v in row])
+    return buf.getvalue().rstrip("\n")
+
+
+def rows_to_columns(rows: QueryRows) -> dict[str, list[Any]]:
+    """Column-oriented, insertion-ordered `{name: [values, …]}` — the dashboard
+    `window.queries` shape."""
+    cols: dict[str, list[Any]] = {c.name: [] for c in rows.meta}
+    names = [c.name for c in rows.meta]
+    for row in rows.data:
+        for i, name in enumerate(names):
+            cols[name].append(row[i] if i < len(row) else None)
+    return cols

{queryview-0.0.2 → queryview-0.0.4}/backend/queryview/drivers/clickhouse.py

@@ -2,12 +2,13 @@
 
 from __future__ import annotations
 
+import json
 from dataclasses import asdict, dataclass
 from typing import Any, NamedTuple
 
 import httpx
 
-from .base import QueryResult, build_order_by, parse_host_port_config, wrap_paginated
+from .base import Column, QueryResult, QueryRows, TextResult, build_order_by, parse_host_port_config, wrap_paginated
 
 CH_TIMEOUT_SECONDS = 5.0
 
@@ -25,12 +26,30 @@ class ChResult(NamedTuple):
     value: str
 
 
-async def ch_query(c: ChConfig, query: str, database: str | None = None, fmt: str | None = None) -> ChResult:
+# JSONCompact output settings: values a JS number would mangle are quoted by
+# ClickHouse itself, and named tuples arrive as objects so the UI can label
+# their fields.
+JSON_COMPACT_SETTINGS = {
+    "output_format_json_quote_64bit_integers": "1",
+    "output_format_json_quote_decimals": "1",
+    "output_format_json_quote_denormals": "1",
+    "output_format_json_named_tuples_as_objects": "1",
+}
+
+
+async def ch_query(
+    c: ChConfig,
+    query: str,
+    database: str | None = None,
+    fmt: str | None = None,
+    settings: dict[str, str] | None = None,
+) -> ChResult:
     """Run a query against the ClickHouse HTTP interface (Basic auth, 5s timeout).
-    `database` scopes the query; `fmt` appends a ClickHouse `FORMAT` clause."""
+    `database` scopes the query; `fmt` appends a ClickHouse `FORMAT` clause;
+    `settings` are passed as URL parameters."""
     url = f"http://{c.host}:{c.port}/"
     q = f"{query}\nFORMAT {fmt}" if fmt else query
-    params = {"query": q}
+    params = {"query": q, **(settings or {})}
     if database:
         params["database"] = database
     try:
@@ -120,13 +139,33 @@ class ClickHouseDriver:
         limit: int,
         offset: int,
         order_by: list[dict[str, Any]] | None,
-        fmt: str,
     ) -> QueryResult:
         order_clause = build_order_by(order_by, "`")
         paginated = wrap_paginated(sql, order_clause, limit, offset, alias=None)
-        ch_fmt = "CSVWithNames" if fmt == "csv" else "TabSeparatedWithNames"
-        r = await ch_query(config, paginated, database=database, fmt=ch_fmt)
-        return QueryResult(r.ok, r.value)
+        r = await ch_query(config, paginated, database=database, fmt="JSONCompact", settings=JSON_COMPACT_SETTINGS)
+        if not r.ok:
+            return QueryResult(False, None, r.value)
+        try:
+            doc = json.loads(r.value)
+            meta = [Column(str(m["name"]), str(m["type"])) for m in doc["meta"]]
+            data = [list(row) for row in doc["data"]]
+        except (ValueError, KeyError, TypeError) as err:
+            return QueryResult(False, None, f"unexpected JSON from ClickHouse: {err}")
+        return QueryResult(True, QueryRows(meta, data))
+
+    async def export_csv(
+        self,
+        config: ChConfig,
+        sql: str,
+        database: str | None,
+        limit: int,
+        offset: int,
+        order_by: list[dict[str, Any]] | None,
+    ) -> TextResult:
+        order_clause = build_order_by(order_by, "`")
+        paginated = wrap_paginated(sql, order_clause, limit, offset, alias=None)
+        r = await ch_query(config, paginated, database=database, fmt="CSVWithNames")
+        return TextResult(r.ok, r.value)
 
     async def describe_query(
         self, config: ChConfig, sql: str, database: str | None

{queryview-0.0.2 → queryview-0.0.4}/backend/queryview/drivers/duckdb.py

@@ -9,7 +9,7 @@ from typing import Any
 
 import duckdb
 
-from .base import QueryResult, build_order_by, serialize_rows, wrap_paginated
+from .base import Column, QueryResult, QueryRows, TextResult, build_order_by, to_csv, to_json_value, wrap_paginated
 
 
 @dataclass(frozen=True)
@@ -104,7 +104,7 @@ class DuckDBDriver:
         except Exception as e:  # noqa: BLE001
             return False, str(e)
 
-    async def run_query(
+    async def _fetch_page(
         self,
         config: DuckConfig,
         sql: str,
@@ -112,26 +112,50 @@ class DuckDBDriver:
         limit: int,
         offset: int,
         order_by: list[dict[str, Any]] | None,
-        fmt: str,
-    ) -> QueryResult:
+    ) -> QueryRows:
         order_clause = build_order_by(order_by, '"')
         paginated = wrap_paginated(sql, order_clause, limit, offset, alias="_qv")
 
-        def _work():
+        def _work() -> QueryRows:
             con = _open(config.path)
             try:
-                cur = con.execute(paginated)
-                columns = [d[0] for d in cur.description] if cur.description else []
-                rows = cur.fetchall()
-                return columns, rows
+                # A relation exposes DuckDB's own type names alongside the rows.
+                rel = con.sql(paginated)
+                meta = [Column(name, str(t)) for name, t in zip(rel.columns, rel.types, strict=True)]
+                return QueryRows(meta, [[to_json_value(v) for v in row] for row in rel.fetchall()])
             finally:
                 con.close()
 
+        return await asyncio.to_thread(_work)
+
+    async def run_query(
+        self,
+        config: DuckConfig,
+        sql: str,
+        database: str | None,
+        limit: int,
+        offset: int,
+        order_by: list[dict[str, Any]] | None,
+    ) -> QueryResult:
+        try:
+            return QueryResult(True, await self._fetch_page(config, sql, database, limit, offset, order_by))
+        except Exception as e:  # noqa: BLE001
+            return QueryResult(False, None, str(e))
+
+    async def export_csv(
+        self,
+        config: DuckConfig,
+        sql: str,
+        database: str | None,
+        limit: int,
+        offset: int,
+        order_by: list[dict[str, Any]] | None,
+    ) -> TextResult:
         try:
-            columns, rows = await asyncio.to_thread(_work)
-            return QueryResult(True, serialize_rows(columns, rows, fmt))
+            rows = await self._fetch_page(config, sql, database, limit, offset, order_by)
         except Exception as e:  # noqa: BLE001
-            return QueryResult(False, str(e))
+            return TextResult(False, str(e))
+        return TextResult(True, to_csv([c.name for c in rows.meta], rows.data))
 
     async def describe_query(
         self, config: DuckConfig, sql: str, database: str | None

{queryview-0.0.2 → queryview-0.0.4}/backend/queryview/drivers/postgres.py

@@ -10,10 +10,14 @@ from typing import Any
 import asyncpg
 
 from .base import (
+    Column,
     QueryResult,
+    QueryRows,
+    TextResult,
     build_order_by,
     parse_host_port_config,
-    serialize_rows,
+    to_csv,
+    to_json_value,
     wrap_paginated,
 )
 
@@ -133,7 +137,7 @@ class PostgresDriver:
         except Exception as e:  # noqa: BLE001
             return False, str(e) or "connection failed"
 
-    async def run_query(
+    async def _fetch_page(
         self,
         config: PgConfig,
         sql: str,
@@ -141,18 +145,43 @@ class PostgresDriver:
         limit: int,
         offset: int,
         order_by: list[dict[str, Any]] | None,
-        fmt: str,
-    ) -> QueryResult:
+    ) -> QueryRows:
         order_clause = build_order_by(order_by, '"')
         paginated = wrap_paginated(sql, order_clause, limit, offset, alias="_qv")
+        async with _connect(config, database) as conn:
+            stmt = await conn.prepare(paginated)
+            meta = [Column(a.name, a.type.name) for a in stmt.get_attributes()]
+            records = await stmt.fetch()
+            return QueryRows(meta, [[to_json_value(v) for v in r] for r in records])
+
+    async def run_query(
+        self,
+        config: PgConfig,
+        sql: str,
+        database: str | None,
+        limit: int,
+        offset: int,
+        order_by: list[dict[str, Any]] | None,
+    ) -> QueryResult:
         try:
-            async with _connect(config, database) as conn:
-                stmt = await conn.prepare(paginated)
-                columns = [a.name for a in stmt.get_attributes()]
-                records = await stmt.fetch()
-                return QueryResult(True, serialize_rows(columns, [list(r) for r in records], fmt))
+            return QueryResult(True, await self._fetch_page(config, sql, database, limit, offset, order_by))
+        except Exception as e:  # noqa: BLE001
+            return QueryResult(False, None, str(e) or "connection failed")
+
+    async def export_csv(
+        self,
+        config: PgConfig,
+        sql: str,
+        database: str | None,
+        limit: int,
+        offset: int,
+        order_by: list[dict[str, Any]] | None,
+    ) -> TextResult:
+        try:
+            rows = await self._fetch_page(config, sql, database, limit, offset, order_by)
         except Exception as e:  # noqa: BLE001
-            return QueryResult(False, str(e) or "connection failed")
+            return TextResult(False, str(e) or "connection failed")
+        return TextResult(True, to_csv([c.name for c in rows.meta], rows.data))
 
     async def describe_query(
         self, config: PgConfig, sql: str, database: str | None