sqlide 0.1.0__py3-none-any.whl

sqlide/ui/widgets/schema_tree.py

@@ -0,0 +1,145 @@
+"""Schema tree: namespaces → tables/views → columns, loaded lazily from a MetaCache."""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import Tree
+from textual.widgets.tree import TreeNode
+
+from sqlide.db.metadata import Column, MetaCache, Namespace, Table, is_system_namespace
+from sqlide.db.result import DbError
+
+ICON_NS, ICON_TABLE, ICON_VIEW = "▣", "▤", "◫"
+
+
+class SchemaTree(Tree[object]):
+    BINDINGS = [
+        Binding("f5", "refresh", "Refresh", id="schema.refresh"),
+        Binding("i", "insert_name", "Insert name", id="schema.insert_name"),
+    ]
+
+    class TableChosen(Message):
+        """`action` is "select" (open first rows) or "insert" (put the name into the editor)."""
+
+        def __init__(self, table: Table, action: str) -> None:
+            super().__init__()
+            self.table, self.action = table, action
+
+    def __init__(self, **kw) -> None:
+        super().__init__("not connected", **kw)
+        self.auto_expand = False  # Enter on a table runs it; Space / arrows expand
+        self.show_root = True
+        self._meta: MetaCache | None = None
+        self._label = ""
+
+    # --- binding to a connection ---
+    def show(self, meta: MetaCache | None, label: str = "") -> None:
+        """Show another connection's metadata (None: disconnected)."""
+        self._meta, self._label = meta, label
+        self.root.set_label(label or "not connected")
+        self.root.remove_children()
+        self.root.data = None
+        if meta is not None:
+            self.root.data = meta
+            self.root.expand()
+            self.run_worker(self._load_namespaces(meta, self.root), group="schema", exclusive=True)
+
+    def action_refresh(self) -> None:
+        if self._meta is not None:
+            self._meta.refresh()
+            self.show(self._meta, self._label)
+
+    # --- lazy loading ---
+    def _placeholder(self, node: TreeNode, text: str = "loading…") -> None:
+        node.remove_children()
+        node.add_leaf(Text(text, style="dim italic"))
+
+    def _fail(self, node: TreeNode, e: Exception) -> None:
+        node.remove_children()
+        node.add_leaf(Text(f"✖ {str(e).splitlines()[0] if str(e) else e!r}", style="red"))
+
+    async def _load_namespaces(self, meta: MetaCache, node: TreeNode) -> None:
+        self._placeholder(node)
+        try:
+            spaces = await meta.namespaces()
+        except DbError as e:
+            self._fail(node, e)
+            return
+        if meta is not self._meta:
+            return  # the user switched tabs meanwhile
+        try:
+            current = (await meta.current_namespace()).lower()
+        except DbError:
+            current = ""
+        # the working schema first, system schemas last and dimmed
+        spaces = sorted(
+            spaces, key=lambda n: (is_system_namespace(n.name), n.name.lower() != current)
+        )
+        node.remove_children()
+        opened = None
+        for ns in spaces:
+            style = "dim" if is_system_namespace(ns.name) else ""
+            child = node.add(Text(f"{ICON_NS} {ns.name or 'main'}", style=style), data=ns)
+            if opened is None and ns.name.lower() == current:
+                opened = child
+        if opened is None and len(spaces) == 1:
+            opened = node.children[0]
+        if opened is not None:
+            opened.expand()
+
+    async def _load_tables(self, meta: MetaCache, node: TreeNode, ns: Namespace) -> None:
+        self._placeholder(node)
+        try:
+            tables = await meta.tables(ns)
+        except DbError as e:
+            self._fail(node, e)
+            return
+        node.remove_children()
+        for t in tables:
+            icon = ICON_VIEW if t.is_view else ICON_TABLE
+            node.add(Text(f"{icon} {t.name}"), data=t)
+        if not tables:
+            node.add_leaf(Text("(empty)", style="dim italic"))
+
+    async def _load_columns(self, meta: MetaCache, node: TreeNode, table: Table) -> None:
+        self._placeholder(node)
+        try:
+            cols = await meta.columns(table)
+        except DbError as e:
+            self._fail(node, e)
+            return
+        node.remove_children()
+        for c in cols:
+            node.add_leaf(_column_label(c), data=c)
+
+    def on_tree_node_expanded(self, event: Tree.NodeExpanded[object]) -> None:
+        node, meta = event.node, self._meta
+        if meta is None or node.children:
+            return  # already loaded
+        if isinstance(node.data, Namespace):
+            self.run_worker(self._load_tables(meta, node, node.data), group=f"ns-{node.id}")
+        elif isinstance(node.data, Table):
+            self.run_worker(self._load_columns(meta, node, node.data), group=f"t-{node.id}")
+
+    # --- actions ---
+    def on_tree_node_selected(self, event: Tree.NodeSelected[object]) -> None:
+        event.stop()
+        if isinstance(event.node.data, Table):
+            self.post_message(self.TableChosen(event.node.data, "select"))
+        elif event.node.allow_expand:
+            event.node.toggle()
+
+    def action_insert_name(self) -> None:
+        node = self.cursor_node
+        if node is not None and isinstance(node.data, Table):
+            self.post_message(self.TableChosen(node.data, "insert"))
+
+
+def _column_label(c: Column) -> Text:
+    text = Text()
+    text.append("🔑 " if c.primary_key else "   ")
+    text.append(c.name)
+    text.append(f"  {c.type_name}{'' if c.nullable else ' not null'}", style="dim")
+    return text

sqlide/ui/widgets/sql_editor.py

@@ -0,0 +1,310 @@
+"""SQL editor: TextArea + a frame around the statement that would run now."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from rich.segment import Segment
+from rich.style import Style
+from textual.binding import Binding
+from textual.color import Color
+from textual.document._document import Document
+from textual.events import Key
+from textual.geometry import Offset
+from textual.message import Message
+from textual.strip import Strip
+from textual.timer import Timer
+from textual.widgets import TextArea
+
+from sqlide.db.completion import Candidate
+from sqlide.sql.format import FormatError, format_sql, toggle_line_comments
+from sqlide.sql.splitter import Span, span_lines, split, statement_at
+from sqlide.ui.widgets.completion_popup import CompletionPopup
+
+IMMEDIATE_RECALC_LIMIT = 20_000  # chars; above this, recompute spans with a short debounce
+DEBOUNCE_S = 0.08
+COMPLETE_DEBOUNCE_S = 0.05
+
+
+class SqlEditor(TextArea):
+    BINDINGS = [
+        Binding("f5,ctrl+j,ctrl+enter", "run_statement", "Run", priority=True, id="editor.run"),
+        Binding(
+            "shift+f5,ctrl+shift+enter", "run_all", "Run all", priority=True, id="editor.run_all"
+        ),
+        Binding("ctrl+space,ctrl+@", "complete", "Complete", show=False, id="editor.complete"),
+        Binding("ctrl+alt+l,f7", "format", "Format", show=False, id="editor.format"),
+        Binding(
+            "ctrl+slash,ctrl+underscore,alt+slash",
+            "toggle_comment",
+            "Comment",
+            show=False,
+            id="editor.toggle_comment",
+        ),
+    ]
+
+    class RunRequested(Message):
+        """User wants to execute these statements, in order."""
+
+        def __init__(self, statements: list[str]) -> None:
+            super().__init__()
+            self.statements = statements
+
+    class CompletionRequested(Message):
+        """Cursor context changed (or the user asked): the owner supplies candidates."""
+
+        def __init__(self, offset: int, text: str, manual: bool) -> None:
+            super().__init__()
+            self.offset, self.text, self.manual = offset, text, manual
+
+    def __init__(self, text: str = "", *, dialect: str = "generic", blank_line: bool = True,
+                 **kw) -> None:  # fmt: skip
+        super().__init__(
+            text,
+            language="sql",
+            theme="monokai",
+            show_line_numbers=True,
+            soft_wrap=False,
+            tab_behavior="indent",
+            placeholder="-- connect (sidebar: Enter), then F5 / Ctrl+J runs the framed statement",
+            **kw,
+        )
+        self._dialect = dialect
+        self._blank_line = blank_line
+        self._spans: list[Span] = []
+        self._frame: tuple[int, int] | None = None
+        self._timer: Timer | None = None
+        self._popup: CompletionPopup | None = None
+        self._complete_timer: Timer | None = None
+        self._prefix_len = 0
+        self._accepting = False
+
+    # --- configuration ---
+    @property
+    def dialect(self) -> str:
+        return self._dialect
+
+    @dialect.setter
+    def dialect(self, value: str) -> None:
+        self._dialect = value
+        self._recalc()
+
+    @property
+    def blank_line(self) -> bool:
+        return self._blank_line
+
+    @blank_line.setter
+    def blank_line(self, value: bool) -> None:
+        self._blank_line = value
+        self._recalc()
+
+    # --- spans and frame ---
+    def _recalc(self) -> None:
+        self._spans = split(self.text, self._dialect, self._blank_line)
+        self._update_frame()
+
+    def _cursor_index(self) -> int:
+        """Cursor as a character offset into `self.text`."""
+        return cast(Document, self.document).get_index_from_location(self.cursor_location)
+
+    def _update_frame(self) -> None:
+        frame = None
+        if self.selection.is_empty:
+            span = statement_at(self._spans, self.text, self._cursor_index())
+            if span:
+                frame = span_lines(self.text, span)
+        if frame != self._frame:
+            self._frame = frame
+            self.refresh()
+
+    @property
+    def frame_lines(self) -> tuple[int, int] | None:
+        """(first, last) 0-based lines of the framed statement, or None."""
+        return self._frame
+
+    def on_mount(self) -> None:
+        self._recalc()
+
+    def on_text_area_changed(self, _: TextArea.Changed) -> None:
+        self._maybe_complete()
+        if len(self.text) <= IMMEDIATE_RECALC_LIMIT:
+            self._recalc()
+            return
+        if self._timer:
+            self._timer.stop()
+        self._timer = self.set_timer(DEBOUNCE_S, self._recalc)
+
+    def on_text_area_selection_changed(self, _: TextArea.SelectionChanged) -> None:
+        self._update_frame()
+        if self.completing:
+            self._request_completion(manual=False)  # re-filter, or close when the cursor left
+
+    # --- run actions ---
+    def statements_to_run(self) -> list[str]:
+        """Selection (split into statements) wins; otherwise the framed statement."""
+        sel = self.selected_text
+        if sel.strip():
+            parts = [s.text(sel) for s in split(sel, self._dialect, self._blank_line)]
+            return parts or [sel.strip()]
+        self._recalc()  # never run from stale spans
+        span = statement_at(self._spans, self.text, self._cursor_index())
+        return [span.text(self.text)] if span else []
+
+    def action_run_statement(self) -> None:
+        stmts = self.statements_to_run()
+        if stmts:
+            self.post_message(self.RunRequested(stmts))
+        else:
+            self.app.notify("No statement at cursor", severity="warning")
+
+    def action_run_all(self) -> None:
+        self._recalc()
+        stmts = [s.text(self.text) for s in self._spans]
+        if stmts:
+            self.post_message(self.RunRequested(stmts))
+        else:
+            self.app.notify("Nothing to run", severity="warning")
+
+    # --- editing helpers ---
+    def action_format(self) -> None:
+        """Pretty-print the selection, or the framed statement."""
+        sel = self.selection
+        if not sel.is_empty:
+            start, end = sorted((sel.start, sel.end))
+            src = self.get_text_range(start, end)
+        else:
+            self._recalc()
+            span = statement_at(self._spans, self.text, self._cursor_index())
+            if span is None:
+                self.app.notify("No statement at cursor", severity="warning")
+                return
+            doc = cast(Document, self.document)
+            start, end = (
+                doc.get_location_from_index(span.start),
+                doc.get_location_from_index(span.end),
+            )
+            src = span.text(self.text)
+        try:
+            formatted = format_sql(src, self._dialect)
+        except FormatError as e:
+            self.app.notify(str(e), title="Cannot format", severity="warning")
+            return
+        if formatted != src:
+            self.replace(formatted, start, end)
+
+    def action_toggle_comment(self) -> None:
+        sel = self.selection
+        first, last = sorted((sel.start[0], sel.end[0]))
+        if not sel.is_empty and sel.end[1] == 0 and sel.end[0] > sel.start[0]:
+            last -= 1  # a selection ending at column 0 does not include that line
+        lines = [self.document.get_line(i) for i in range(first, last + 1)]
+        new = toggle_line_comments(lines)
+        if new != lines:
+            end_col = len(lines[-1])
+            self.replace("\n".join(new), (first, 0), (last, end_col))
+
+    # --- drawing ---
+    def render_line(self, y: int) -> Strip:
+        strip = super().render_line(y)
+        if self._frame is None or not self.show_line_numbers:
+            return strip
+        row = y + self.scroll_offset.y
+        if row >= self.wrapped_document.height:  # empty space below the text: no frame
+            return strip
+        line, _ = self.wrapped_document.offset_to_location(Offset(0, row))
+        first, last = self._frame
+        if not first <= line <= last:
+            return strip
+        mark = "▏" if first == last else "┏" if line == first else "┗" if line == last else "┃"
+        accent, tint = self._frame_colors()
+        segs = list(strip)
+        head = segs[0]
+        segs[0] = Segment(mark + head.text[1:], (head.style or Style()) + Style(color=accent))
+        segs = [Segment(s.text, (s.style or Style()) + tint, s.control) for s in segs]
+        return Strip(segs, strip.cell_length)
+
+    def _frame_colors(self) -> tuple[str, Style]:
+        theme = self.app.current_theme
+        accent = Color.parse(theme.primary)
+        base = Color.parse(theme.background if theme.background else "#1e1e1e")
+        return accent.hex, Style(bgcolor=base.blend(accent, 0.14).hex)
+
+    # --- autocomplete (the data comes from the owner via CompletionRequested) ---
+    @property
+    def completing(self) -> bool:
+        return self._popup is not None and self._popup.shown
+
+    def action_complete(self) -> None:
+        self._request_completion(manual=True)
+
+    def _maybe_complete(self) -> None:
+        """Auto-open after a dot; keep an open popup in sync while typing."""
+        if self._accepting:
+            return
+        before = self.text[self._cursor_index() - 1 : self._cursor_index()]
+        if before == "." or self.completing:
+            self._request_completion(manual=False)
+
+    def _request_completion(self, manual: bool) -> None:
+        if self._complete_timer is not None:
+            self._complete_timer.stop()
+        self._complete_timer = self.set_timer(
+            COMPLETE_DEBOUNCE_S,
+            lambda: self.post_message(
+                self.CompletionRequested(self._cursor_index(), self.text, manual)
+            ),
+        )
+
+    def show_completions(self, items: list[Candidate], prefix_len: int) -> None:
+        if not items or not self.has_focus:
+            self.hide_completions()
+            return
+        if self._popup is None:
+            self._popup = CompletionPopup()
+            self.screen.mount(self._popup)
+        self._prefix_len = prefix_len
+        self._popup.show(items, self.cursor_screen_offset)
+
+    def hide_completions(self) -> None:
+        if self._popup is not None:
+            self._popup.hide()
+
+    def _accept_completion(self) -> None:
+        popup = self._popup
+        choice = popup.current if popup else None
+        self.hide_completions()
+        if choice is None:
+            return
+        end = self._cursor_index()
+        doc = cast(Document, self.document)
+        self._accepting = True
+        try:
+            self.replace(
+                choice.text,
+                doc.get_location_from_index(end - self._prefix_len),
+                doc.get_location_from_index(end),
+            )
+        finally:
+            self._accepting = False
+
+    def on_blur(self) -> None:
+        self.hide_completions()
+
+    # Tab indents instead of moving focus (tab_behavior="indent"); Shift+Tab moves focus out.
+    def on_key(self, event: Key) -> None:
+        if self.completing and self._popup is not None:
+            handled = {
+                "down": lambda: self._popup.move(1),  # type: ignore[union-attr]
+                "up": lambda: self._popup.move(-1),  # type: ignore[union-attr]
+                "enter": self._accept_completion,
+                "tab": self._accept_completion,
+                "escape": self.hide_completions,
+            }.get(event.key)
+            if handled:
+                event.stop()
+                event.prevent_default()
+                handled()
+                return
+        if event.key == "shift+tab":
+            event.stop()
+            self.screen.focus_previous()

sqlide/ui/widgets/status_bar.py

@@ -0,0 +1,32 @@
+"""One-line status: connection, transaction mode, last run summary."""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual.widgets import Static
+
+
+class StatusBar(Static):
+    DEFAULT_CSS = """
+    StatusBar { height: 1; padding: 0 1; background: $panel; color: $text-muted; }
+    """
+
+    def __init__(self, **kw) -> None:
+        super().__init__("", **kw)
+        self.connection = "not connected"
+        self.tx = ""
+        self.message = ""
+        self._refresh_text()
+
+    def update_state(self, **fields: str) -> None:
+        for k, v in fields.items():
+            setattr(self, k, v)
+        self._refresh_text()
+
+    def _refresh_text(self) -> None:
+        parts = [self.connection]
+        if self.tx:
+            parts.append(f"Tx: {self.tx}")
+        if self.message:
+            parts.append(self.message)
+        self.update(Text(" · ".join(parts)))

sqlide/workspace.py

@@ -0,0 +1,97 @@
+"""Application service: saved connections, drivers, passwords, sessions.
+
+Everything the UI needs from the non-UI blocks, in one place. Holds no widgets.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+
+from sqlide.config.connections import Connection, ConnectionStore
+from sqlide.config.secrets import PasswordResolver
+from sqlide.config.settings import Settings, load_settings
+from sqlide.consoles import ConsoleStore
+from sqlide.db.factory import create_session, is_private_database
+from sqlide.db.session import DbSession
+from sqlide.drivers.registry import DriverDef, DriverRegistry
+from sqlide.history import HistoryStore
+from sqlide.jvm.runtime import ensure_jvm
+
+
+class Workspace:
+    def __init__(
+        self,
+        store: ConnectionStore | None = None,
+        registry: DriverRegistry | None = None,
+        resolver: PasswordResolver | None = None,
+        settings: Settings | None = None,
+        consoles: ConsoleStore | None = None,
+        history: HistoryStore | None = None,
+    ) -> None:
+        self.store = store or ConnectionStore()
+        self.registry = registry or DriverRegistry()
+        self.resolver = resolver or PasswordResolver()
+        self.settings = settings or load_settings()
+        self.consoles = consoles or ConsoleStore()
+        self.history = history or HistoryStore(limit=self.settings.history_limit)
+
+    # --- connections ---
+    def connections(self) -> list[Connection]:
+        return self.store.load()
+
+    def save_connection(self, conn: Connection, replaces: str | None = None) -> None:
+        if replaces and replaces != conn.name:
+            self.store.remove(replaces)
+        self.store.upsert(conn)
+
+    def delete_connection(self, name: str) -> None:
+        self.store.remove(name)
+        self.resolver.forget(name)
+
+    # --- drivers ---
+    def driver(self, driver_id: str) -> DriverDef:
+        return self.registry.get(driver_id)
+
+    def driver_ready(self, conn: Connection) -> bool:
+        return self.registry.is_installed(conn.driver)
+
+    async def install_driver(
+        self, driver_id: str, progress: Callable[[int, int | None], None] | None = None
+    ) -> None:
+        await asyncio.to_thread(self.registry.install, driver_id, None, None, progress)
+
+    # --- sessions ---
+    @staticmethod
+    def needs_password_prompt(conn: Connection) -> bool:
+        """No user means no credentials (sqlite, h2, duckdb): never ask."""
+        return bool(conn.user)
+
+    async def lookup_password(self, conn: Connection) -> str | None:
+        return await asyncio.to_thread(self.resolver.lookup, conn)
+
+    async def connect_for_metadata(self, conn: Connection) -> DbSession | None:
+        """A second connection for schema reads, so they never queue behind a running query.
+
+        None when that is not possible (in-memory database, password not known, any error):
+        the caller then keeps using the main session.
+        """
+        if is_private_database(conn.url):
+            return None
+        try:
+            password = await self.lookup_password(conn)
+            if password is None and self.needs_password_prompt(conn):
+                return None
+            return await self.connect(conn, password)
+        except Exception:  # noqa: BLE001 - purely an optimisation
+            return None
+
+    async def connect(self, conn: Connection, password: str | None) -> DbSession:
+        await asyncio.to_thread(ensure_jvm)
+        session = await asyncio.to_thread(create_session, conn, password or None, self.registry)
+        try:
+            await session.open()
+        except BaseException:
+            await session.close()
+            raise
+        return session