sqlide 0.1.0__py3-none-any.whl

sqlide/ui/widgets/console_export.py

@@ -0,0 +1,124 @@
+"""Export wiring for a console: dialog -> exporter -> status.
+
+Mixed into ConsoleTab. Delete this file (and the base class) to drop export from the UI.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from sqlide import export
+from sqlide.db.result import DbError
+from sqlide.db.session import DbSession
+from sqlide.export import ExportCancelled, ExportOptions
+from sqlide.export.service import export_query, export_rows
+from sqlide.ui.screens.export_dialog import ExportContext, ExportRequest, ExportScreen
+from sqlide.ui.widgets.result_grid import ResultGrid
+
+if TYPE_CHECKING:
+    from sqlide.ui.widgets.console_tab import ConsoleTab
+
+
+class ExportActions:
+    """Expects the host to be a ConsoleTab (ws, conn, status, panel, app, run_worker)."""
+
+    _exporting = False
+    _export_cancel = False
+    _export_session: DbSession | None = None
+
+    def cancel_export(self) -> bool:
+        """Request cancellation of a running export. False if none is running."""
+        if not self._exporting:
+            return False
+        self._export_cancel = True
+        if self._export_session is not None:
+            self._export_session.cancel()
+        self._host.status.update_state(message="cancelling export…")
+        return True
+
+    @property
+    def _host(self) -> ConsoleTab:
+        return self  # type: ignore[return-value]
+
+    def on_result_grid_export_requested(self, message: ResultGrid.ExportRequested) -> None:
+        message.stop()
+        host, grid = self._host, message.grid
+        if self._exporting:
+            host.app.notify("An export is already running", severity="warning")
+            return
+        r0, c0, r1, c1 = grid.selection_rect()
+        ctx = ExportContext(
+            n_view=len(grid.model),
+            selection=((r1 - r0 + 1, c1 - c0 + 1) if (r1 > r0 or c1 > c0) else None),
+            can_requery=bool(grid.sql and host.conn is not None),
+            more_rows=grid.source is not None,
+        )
+        host.app.push_screen(
+            ExportScreen(ctx), lambda req: self._start_export(grid, req) if req else None
+        )
+
+    def _start_export(self, grid: ResultGrid, req: ExportRequest) -> None:
+        self._host.run_worker(self._do_export(grid, req), group="export", exit_on_error=False)
+
+    async def _do_export(self, grid: ResultGrid, req: ExportRequest) -> None:
+        host = self._host
+        exporter = export.get(req.format)
+        self._exporting, self._export_cancel = True, False
+
+        def progress(n: int) -> None:  # called from a worker thread
+            host.app.call_from_thread(host.status.update_state, message=f"exporting… {n:,} rows")
+
+        opts = ExportOptions(
+            header=req.header,
+            delimiter=req.delimiter,
+            bom=req.bom,
+            table_name=req.table_name,
+            progress=progress,
+            should_cancel=lambda: self._export_cancel,
+        )
+        host.status.update_state(message="exporting…")
+        try:
+            if req.scope == "all":
+                count = await self._export_all(exporter, grid, req.path, opts)
+            elif req.scope == "selection":
+                columns, rows = grid.selection_data()
+                count = await export_rows(exporter, columns, rows, req.path, opts)
+            else:
+                rows = grid.model.rows(0, len(grid.model) - 1)
+                count = await export_rows(exporter, grid.model.columns, rows, req.path, opts)
+        except ExportCancelled:
+            host.app.notify("Export cancelled", severity="warning")
+            host.status.update_state(message="export cancelled")
+        except Exception as e:  # file system, driver, or DB errors: show, never crash the UI
+            host.panel.log_error(f"✖ Export failed: {e}")
+            host.app.notify(str(e), title="Export failed", severity="error")
+            host.status.update_state(message="export failed")
+        else:
+            size = req.path.stat().st_size
+            msg = f"Exported {count:,} rows to {req.path} ({size / 1024:.1f} KB)"
+            host.panel.log_line(msg, "green")
+            host.app.notify(msg)
+            host.status.update_state(message=f"exported {count:,} rows")
+        finally:
+            self._exporting = False
+
+    async def _export_all(
+        self, exporter: export.Exporter, grid: ResultGrid, path: Path, opts: ExportOptions
+    ) -> int:
+        """Re-run the statement on a private connection and stream it into the file."""
+        host = self._host
+        assert host.conn is not None
+        password = await host.ws.lookup_password(host.conn)
+        session = await host.ws.connect(host.conn, password)
+        self._export_session = session
+        try:
+            return await export_query(exporter, session, grid.sql, path, opts)
+        except DbError:
+            if self._export_cancel:
+                raise ExportCancelled from None
+            raise
+        finally:
+            self._export_session = None
+            await asyncio.shield(session.close())

sqlide/ui/widgets/console_tab.py

@@ -0,0 +1,335 @@
+"""One console: editor + results + status, bound to one DB session and one SQL file."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from time import monotonic
+from typing import cast
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.message import Message
+from textual.timer import Timer
+from textual.widgets import TextArea
+
+from sqlide.config.connections import Connection
+from sqlide.consoles import CONSOLE, FILE, TabState
+from sqlide.db.completion import candidates
+from sqlide.db.metadata import MetaCache
+from sqlide.db.result import DbError
+from sqlide.db.session import DbSession
+from sqlide.sql.context import analyze
+from sqlide.sql.snippets import is_ddl
+from sqlide.ui.widgets.console_export import ExportActions
+from sqlide.ui.widgets.result_grid import ResultGrid
+from sqlide.ui.widgets.result_panel import ResultPanel
+from sqlide.ui.widgets.sql_editor import SqlEditor
+from sqlide.ui.widgets.status_bar import StatusBar
+from sqlide.workspace import Workspace
+
+AUTOSAVE_S = 1.0
+
+
+def one_line(sql: str, limit: int = 100) -> str:
+    text = " ".join(sql.split())
+    return text if len(text) <= limit else text[: limit - 1] + "…"
+
+
+class ConsoleTab(ExportActions, Vertical):
+    BINDINGS = [
+        Binding("ctrl+f2", "cancel", "Cancel", id="console.cancel"),
+        Binding("f8", "toggle_tx", "Auto/Manual tx", id="console.toggle_tx"),
+        Binding("f9", "commit", "Commit", id="console.commit"),
+        Binding("f10", "rollback", "Rollback", id="console.rollback"),
+    ]
+
+    class TitleChanged(Message):
+        def __init__(self, console: ConsoleTab) -> None:
+            super().__init__()
+            self.console = console
+
+    class SchemaChanged(Message):
+        """A DDL statement ran: cached metadata was dropped, views should reload."""
+
+        def __init__(self, console: ConsoleTab) -> None:
+            super().__init__()
+            self.console = console
+
+    class ConnectRequested(Message):
+        """The console has no session yet but knows which connection it wants."""
+
+        def __init__(self, console: ConsoleTab, conn_name: str, then_run: list[str]) -> None:
+            super().__init__()
+            self.console, self.conn_name, self.then_run = console, conn_name, then_run
+
+    def __init__(
+        self, ws: Workspace, path: Path, kind: str = CONSOLE, conn_name: str = "", **kw
+    ) -> None:
+        super().__init__(**kw)
+        self.ws = ws
+        self.path = path
+        self.kind = kind
+        self.conn_name = conn_name
+        self.conn: Connection | None = None
+        self.session: DbSession | None = None
+        self.meta: MetaCache | None = None
+        self.meta_session: DbSession | None = None
+        self._executing = False
+        self._autosave: Timer | None = None
+        try:
+            self._initial, self._newline = ws.consoles.read(path)
+        except FileNotFoundError:  # a new file named on the command line
+            self._initial, self._newline = "", "\n"
+        self._saved_text = self._initial
+
+    def compose(self) -> ComposeResult:
+        yield SqlEditor(self._initial, blank_line=self.ws.settings.split_on_blank_line, id="editor")
+        yield ResultPanel(id="results")
+        yield StatusBar(id="status")
+
+    # --- parts ---
+    @property
+    def editor(self) -> SqlEditor:
+        return self.query_one("#editor", SqlEditor)
+
+    @property
+    def panel(self) -> ResultPanel:
+        return self.query_one("#results", ResultPanel)
+
+    @property
+    def status(self) -> StatusBar:
+        return self.query_one("#status", StatusBar)
+
+    @property
+    def running(self) -> bool:
+        return self._executing
+
+    # --- identity / files ---
+    @property
+    def dirty(self) -> bool:
+        if self.kind != FILE:
+            return False
+        editors = self.query("#editor")  # not mounted yet while the tab strip is being built
+        return bool(editors) and cast(SqlEditor, editors.first()).text != self._saved_text
+
+    @property
+    def title(self) -> str:
+        name = self.path.stem if self.kind == CONSOLE else self.path.name
+        return (
+            ("● " if self.dirty else "") + name + (f" [{self.conn_name}]" if self.conn_name else "")
+        )
+
+    def tab_state(self, active: bool) -> TabState:
+        return TabState(self.kind, str(self.path), self.conn_name, active)
+
+    def _title_changed(self) -> None:
+        self.post_message(self.TitleChanged(self))
+
+    def on_text_area_changed(self, _: TextArea.Changed) -> None:
+        if self.kind == CONSOLE:
+            if self._autosave is not None:
+                self._autosave.stop()
+            self._autosave = self.set_timer(AUTOSAVE_S, self.flush)
+        else:
+            self._title_changed()
+
+    def flush(self) -> None:
+        """Write a console's text to its autosave file now."""
+        if self.kind == CONSOLE and self.is_mounted:
+            self.ws.consoles.write(self.path, self.editor.text, self._newline)
+
+    def save(self, path: Path | None = None) -> None:
+        """Save to `path` (Save As) or the current file. A console becomes a file tab."""
+        target = path or self.path
+        self.ws.consoles.write(target, self.editor.text, self._newline)
+        self.path, self.kind = target, FILE
+        self._saved_text = self.editor.text
+        self._title_changed()
+
+    # --- connection ---
+    async def attach(self, conn: Connection, session: DbSession) -> None:
+        await self.detach()
+        self.conn, self.session, self.conn_name = conn, session, conn.name
+        self.meta = MetaCache(session)
+        self.run_worker(self._open_meta_session(conn, self.meta), group="meta", exclusive=True)
+        self.editor.dialect = self.ws.driver(conn.driver).dialect
+        self._refresh_tx(message="")
+        self.status.update_state(connection=f"{conn.name} ({session.product})")
+        self.panel.log_line(f"Connected: {conn.name}: {session.product}", "green")
+        self._title_changed()
+
+    async def _open_meta_session(self, conn: Connection, meta: MetaCache) -> None:
+        second = await self.ws.connect_for_metadata(conn)
+        if second is None:
+            return
+        if self.meta is not meta:  # detached or reconnected while we were connecting
+            await second.close()
+            return
+        self.meta_session = second
+        meta.use(second)
+
+    async def detach(self) -> None:
+        self.workers.cancel_group(self, "meta")
+        if self.meta_session is not None:
+            await self.meta_session.close()
+            self.meta_session = None
+        if self.session is not None:
+            await self.session.close()
+        self.conn = self.session = self.meta = None
+        self.status.update_state(connection="not connected", tx="", message="")
+
+    async def shutdown(self) -> None:
+        """Called when the tab goes away: persist text, cancel work, close the connection."""
+        self.cancel_export()
+        self.flush()
+        await self.detach()
+
+    # --- transactions ---
+    def _refresh_tx(self, message: str | None = None) -> None:
+        s = self.session
+        tx = (
+            ""
+            if s is None
+            else "Auto"
+            if s.autocommit
+            else "Manual" + ("*" if s.pending_tx else "")
+        )
+        fields = {"tx": tx}
+        if message is not None:
+            fields["message"] = message
+        self.status.update_state(**fields)
+
+    async def action_toggle_tx(self) -> None:
+        if self.session is None or self._executing:
+            return
+        try:
+            await self.session.set_autocommit(not self.session.autocommit)
+        except DbError as e:
+            self.app.notify(str(e), severity="error")
+        self._refresh_tx(
+            message=f"transaction mode: {'Auto' if self.session.autocommit else 'Manual'}"
+        )
+
+    async def action_commit(self) -> None:
+        await self._finish_tx(commit=True)
+
+    async def action_rollback(self) -> None:
+        await self._finish_tx(commit=False)
+
+    async def _finish_tx(self, commit: bool) -> None:
+        s = self.session
+        if s is None or s.autocommit or self._executing:
+            return
+        try:
+            await (s.commit() if commit else s.rollback())
+        except DbError as e:
+            self.app.notify(str(e), severity="error")
+            return
+        if self.meta is not None:  # DDL committed now becomes visible to the metadata session
+            self.meta.refresh()
+            self.post_message(self.SchemaChanged(self))
+        self.panel.log_line("Committed" if commit else "Rolled back", "green")
+        self._refresh_tx(message="committed" if commit else "rolled back")
+
+    # --- autocomplete ---
+    def on_sql_editor_completion_requested(self, message: SqlEditor.CompletionRequested) -> None:
+        message.stop()
+        self.run_worker(self._complete(message), group="complete", exclusive=True)
+
+    async def _complete(self, req: SqlEditor.CompletionRequested) -> None:
+        dialect = self.editor.dialect
+        ctx = analyze(req.text, req.offset, dialect)
+        if ctx is None or (not ctx.prefix and not ctx.qualifier and not req.manual):
+            self.editor.hide_completions()
+            return
+        items = await candidates(ctx, self.meta, dialect)
+        if self.editor._cursor_index() != req.offset:  # the user typed on; a newer request follows
+            return
+        self.editor.show_completions(items, ctx.replace_len)
+
+    # --- execution ---
+    def on_sql_editor_run_requested(self, message: SqlEditor.RunRequested) -> None:
+        message.stop()
+        self.run_statements(message.statements)
+
+    def run_statements(self, statements: list[str]) -> None:
+        if self.session is None:
+            if self.conn_name and any(c.name == self.conn_name for c in self.ws.connections()):
+                self.post_message(self.ConnectRequested(self, self.conn_name, statements))
+            else:
+                self.app.notify(
+                    "Not connected: pick a connection in the sidebar", severity="warning"
+                )
+        elif self._executing:
+            self.app.notify("A query is running (Ctrl+F2 cancels it)", severity="warning")
+        else:
+            self.run_worker(self._run(statements), group="run")
+
+    def on_result_grid_summary(self, message: ResultGrid.Summary) -> None:
+        message.stop()
+        self.status.update_state(message=message.text)
+
+    def action_cancel(self) -> None:
+        if self.cancel_export():
+            return
+        if self.session is not None and self._executing:
+            self.session.cancel()
+            self.status.update_state(message="cancelling…")
+
+    def _record(self, sql: str, ok: bool, elapsed_s: float, error: str = "") -> None:
+        try:
+            self.ws.history.add(self.conn_name, sql, ok, round(elapsed_s * 1000), error)
+        except Exception as e:  # history must never break running queries
+            self.app.log.warning(f"history: {e}")
+
+    async def _run(self, statements: list[str]) -> None:
+        session = self.session
+        assert session is not None
+        self._executing = True
+        self.status.update_state(message="running…")
+        await self.panel.reset_results()
+        n_results = 0
+        last = ""
+        try:
+            for sql in statements:
+                self.panel.log_line(f"▶ {one_line(sql)}", "bold")
+                started = monotonic()
+                try:
+                    ex = await session.execute(sql, self.ws.settings.fetch_size)
+                except DbError as e:
+                    self._record(sql, False, monotonic() - started, str(e))
+                    self.panel.log_error(f"✖ {e}" + (f"  [{e.sql_state}]" if e.sql_state else ""))
+                    if str(e) == "Cancelled by user":
+                        self.app.notify("Query cancelled", severity="warning")
+                    else:
+                        self.app.notify(str(e), title="Query failed", severity="error")
+                    last = "failed"
+                    break
+                for w in ex.warnings:
+                    self.panel.log_line(f"  {w}", "yellow")
+                for item in ex.items:
+                    if item.has_rows:
+                        n_results += 1
+                        grid = await self.panel.add_result(
+                            f"Result {n_results}",
+                            item.columns,
+                            item.rows,
+                            item.cursor,
+                            self.ws.settings.fetch_size,
+                            sql,
+                        )
+                        last = grid.summary_text
+                    else:
+                        last = f"{item.update_count} rows affected"
+                        self.panel.log_line(f"  {last}")
+                self._record(sql, True, ex.elapsed_s)
+                if is_ddl(sql) and self.meta is not None:
+                    self.meta.refresh()
+                    self.post_message(self.SchemaChanged(self))
+                self.panel.log_line(f"✔ {ex.elapsed_s * 1000:.0f} ms", "green")
+                last = f"{last} in {ex.elapsed_s * 1000:.0f} ms"
+        finally:
+            self._executing = False
+            self._refresh_tx(message=last)
+            self.panel.show_first_result()

sqlide/ui/widgets/console_tabs.py

@@ -0,0 +1,117 @@
+"""The tab strip of consoles: create, restore, close, persist."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.markup import escape
+from textual.widgets import TabbedContent, TabPane
+
+from sqlide.consoles import CONSOLE, FILE, TabState
+from sqlide.ui.widgets.console_tab import ConsoleTab
+from sqlide.workspace import Workspace
+
+
+class ConsoleTabs(TabbedContent):
+    def __init__(self, ws: Workspace, panes: list[TabPane], initial: str, seq: int, **kw) -> None:
+        super().__init__(initial=initial, **kw)
+        for pane in panes:
+            self.compose_add_child(pane)  # same hook the `with TabbedContent():` form uses
+        self.ws = ws
+        self._seq = seq
+
+    @classmethod
+    def build(cls, ws: Workspace, states: list[TabState], files: list[Path], **kw) -> ConsoleTabs:
+        """Tabs of the previous run plus files named on the command line (synchronous)."""
+        consoles: list[tuple[ConsoleTab, bool]] = []
+        for st in states:
+            path = Path(st.path)
+            if path.exists():
+                consoles.append((ConsoleTab(ws, path, st.kind, st.connection), st.active))
+        open_paths = {c.path.resolve() for c, _ in consoles}
+        opened_from_cli: ConsoleTab | None = None
+        for f in files:
+            known = next((c for c, _ in consoles if c.path.resolve() == f.resolve()), None)
+            if known is None and f.resolve() not in open_paths:
+                known = ConsoleTab(ws, f, FILE)
+                consoles.append((known, False))
+            opened_from_cli = known
+        if not consoles:
+            consoles.append((ConsoleTab(ws, ws.consoles.new_console_file(None), CONSOLE), True))
+        active = opened_from_cli or next((c for c, a in consoles if a), consoles[0][0])
+        panes, initial = [], ""
+        for i, (console, _) in enumerate(consoles, 1):
+            pane = TabPane(escape(console.title), console, id=f"c{i}")
+            panes.append(pane)
+            if console is active:
+                initial = f"c{i}"
+        return cls(ws, panes, initial, len(consoles), **kw)
+
+    # --- lookup ---
+    def consoles(self) -> list[ConsoleTab]:
+        return list(self.query(ConsoleTab))
+
+    @property
+    def active_console(self) -> ConsoleTab | None:
+        pane = self.active_pane
+        return pane.query_one(ConsoleTab) if pane is not None else None
+
+    def find_file(self, path: Path) -> ConsoleTab | None:
+        want = path.resolve()
+        return next((c for c in self.consoles() if c.path.resolve() == want), None)
+
+    # --- create / close ---
+    async def add_console(
+        self,
+        *,
+        kind: str = CONSOLE,
+        path: Path | None = None,
+        conn_name: str = "",
+        activate: bool = True,
+    ) -> ConsoleTab:
+        if path is None:
+            path = self.ws.consoles.new_console_file(conn_name or None)
+        self._seq += 1
+        pane_id = f"c{self._seq}"
+        console = ConsoleTab(self.ws, path, kind, conn_name)
+        await self.add_pane(TabPane(escape(console.title), console, id=pane_id))
+        if activate:
+            self.active = pane_id
+        self.persist()
+        return console
+
+    async def close_console(self, console: ConsoleTab) -> None:
+        pane = console.parent
+        await console.shutdown()
+        if isinstance(pane, TabPane) and pane.id:
+            await self.remove_pane(pane.id)
+        if not self.consoles():
+            await self.add_console()
+        self.persist()
+
+    async def shutdown(self) -> None:
+        """App is quitting: remember the tabs, then stop every console."""
+        self.persist()
+        for console in self.consoles():
+            await console.shutdown()
+
+    # --- titles ---
+    def on_console_tab_title_changed(self, message: ConsoleTab.TitleChanged) -> None:
+        message.stop()
+        pane = message.console.parent
+        if isinstance(pane, TabPane) and pane.id:
+            self.get_tab(pane.id).label = escape(message.console.title)  # type: ignore[assignment]
+        self.persist()
+
+    def on_tabbed_content_tab_activated(self, _: TabbedContent.TabActivated) -> None:
+        self.persist()
+
+    # --- persistence ---
+    def persist(self) -> None:
+        active = self.active_console
+        states = [c.tab_state(c is active) for c in self.consoles()]
+        if states:
+            self.ws.consoles.save_state(states)
+
+
+__all__ = ["CONSOLE", "FILE", "ConsoleTabs"]