sqlide 0.1.0__py3-none-any.whl

sqlide/export/sql_insert.py

@@ -0,0 +1,37 @@
+"""SQL INSERT statements."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+from sqlide.db.result import Column
+from sqlide.export.base import Exporter, ExportOptions, Row, register
+from sqlide.grid.copyfmt import sql_ident, sql_literal
+
+
+@register
+class SqlInsertExporter(Exporter):
+    name, label, extension = "sql", "SQL INSERT statements", ".sql"
+
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int:
+        cols = ", ".join(sql_ident(c.name) for c in columns)
+        head = f"INSERT INTO {opts.table_name} ({cols}) VALUES"
+        batch = max(1, opts.batch_size)
+        count, pending = 0, []
+        with tmp.open("w", encoding="utf-8") as f:
+
+            def flush() -> None:
+                if pending:
+                    f.write(head + "\n  " + ",\n  ".join(pending) + ";\n")
+                    pending.clear()
+
+            for row in rows:
+                pending.append("(" + ", ".join(sql_literal(v) for v in row) + ")")
+                count += 1
+                if len(pending) >= batch:
+                    flush()
+            flush()
+        return count

sqlide/export/xlsx.py

@@ -0,0 +1,109 @@
+"""Excel .xlsx via openpyxl write-only mode (constant memory).
+
+Handles Excel limits: 1,048,576 rows per sheet (continues on 'Name 2', ...), 32,767 chars
+per cell, control characters Excel rejects, and the 15-digit float precision (larger
+integers / decimals are written as text so no digits are silently lost).
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import math
+import re
+from collections.abc import Iterator
+from decimal import Decimal
+from itertools import chain, islice
+from pathlib import Path
+from typing import Any
+
+from openpyxl import Workbook
+from openpyxl.cell import WriteOnlyCell
+from openpyxl.styles import Font
+from openpyxl.utils import get_column_letter
+
+from sqlide.db.result import Column
+from sqlide.export.base import Exporter, ExportOptions, Row, register
+
+MAX_ROWS_PER_SHEET = 1_048_576 - 1  # minus the header row
+MAX_CELL_CHARS = 32_767
+SAMPLE_ROWS = 100
+MAX_PRECISE = 10**15
+_ILLEGAL = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f]")
+_BAD_SHEET = re.compile(r"[\[\]:*?/\\]")
+_FORMATS = {dt.datetime: "yyyy-mm-dd hh:mm:ss", dt.date: "yyyy-mm-dd", dt.time: "hh:mm:ss"}
+
+
+def sheet_title(name: str, index: int) -> str:
+    base = _BAD_SHEET.sub("_", name).strip("'") or "Result"
+    suffix = f" {index}" if index > 1 else ""
+    return base[: 31 - len(suffix)] + suffix
+
+
+def to_cell_value(ws: Any, v: Any) -> Any:
+    if v is None or isinstance(v, bool):
+        return v
+    if isinstance(v, int):
+        return v if abs(v) < MAX_PRECISE else str(v)
+    if isinstance(v, float):
+        return v if math.isfinite(v) else str(v)
+    if isinstance(v, Decimal):
+        return float(v) if v.is_finite() and len(v.as_tuple().digits) <= 15 else str(v)
+    for typ, fmt in _FORMATS.items():  # datetime before date: it is a subclass
+        if isinstance(v, typ):
+            cell = WriteOnlyCell(ws, value=v)
+            cell.number_format = fmt
+            return cell
+    if isinstance(v, bytes):
+        return "0x" + v.hex()
+    return _ILLEGAL.sub("", str(v))[:MAX_CELL_CHARS]
+
+
+@register
+class XlsxExporter(Exporter):
+    name, label, extension = "xlsx", "Excel (.xlsx)", ".xlsx"
+
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int:
+        wb = Workbook(write_only=True)
+        total = in_sheet = sheet_no = 0
+        ws: Any = None
+        names = [c.name for c in columns]
+        sample = list(islice(rows, SAMPLE_ROWS))
+        widths = [
+            min(60, max(len(n) + 2, *(len(str(r[i])) if r[i] is not None else 0 for r in sample)))
+            for i, n in enumerate(names)
+        ]
+
+        def new_sheet() -> Any:
+            nonlocal sheet_no
+            sheet_no += 1
+            sheet = wb.create_sheet(sheet_title(opts.sheet_name, sheet_no))
+            for i, w in enumerate(widths, 1):
+                sheet.column_dimensions[get_column_letter(i)].width = w + 1
+            if opts.header:
+                sheet.freeze_panes = "A2"
+                bold = Font(bold=True)
+                cells = []
+                for n in names:
+                    cell = WriteOnlyCell(sheet, value=_ILLEGAL.sub("", n))
+                    cell.font = bold
+                    cells.append(cell)
+                sheet.append(cells)
+            return sheet
+
+        def finish(sheet: Any, n_rows: int) -> None:
+            if opts.header and names and n_rows:
+                sheet.auto_filter.ref = f"A1:{get_column_letter(len(names))}{n_rows + 1}"
+
+        ws = new_sheet()
+        for row in chain(sample, rows):
+            if in_sheet >= MAX_ROWS_PER_SHEET:
+                finish(ws, in_sheet)
+                ws, in_sheet = new_sheet(), 0
+            ws.append([to_cell_value(ws, v) for v in row])
+            in_sheet += 1
+            total += 1
+        finish(ws, in_sheet)
+        wb.save(tmp)
+        return total

sqlide/grid/__init__.py

@@ -0,0 +1 @@
+"""Grid block: result-table model and value formatting. No UI imports."""

sqlide/grid/copyfmt.py

@@ -0,0 +1,97 @@
+"""Text renderings of a block of cells, for the clipboard. Pure functions."""
+
+from __future__ import annotations
+
+import csv
+import datetime as dt
+import io
+import json
+import re
+from collections.abc import Sequence
+from decimal import Decimal
+from typing import Any
+
+from sqlide.grid.formatting import raw_text
+
+Row = tuple[Any, ...]
+
+_PLAIN_IDENT = re.compile(r"^[a-z_][a-z0-9_]*$")
+
+
+def _tsv_cell(v: Any) -> str:
+    s = raw_text(v)
+    if any(ch in s for ch in '\t\n\r"'):
+        return '"' + s.replace('"', '""') + '"'  # Excel/Sheets convention
+    return s
+
+
+def to_tsv(rows: Sequence[Row], header: Sequence[str] | None = None) -> str:
+    lines = []
+    if header is not None:
+        lines.append("\t".join(_tsv_cell(h) for h in header))
+    lines += ["\t".join(_tsv_cell(v) for v in row) for row in rows]
+    return "\n".join(lines)
+
+
+def to_csv(rows: Sequence[Row], header: Sequence[str] | None = None) -> str:
+    buf = io.StringIO()
+    w = csv.writer(buf, lineterminator="\n")
+    if header is not None:
+        w.writerow(header)
+    for row in rows:
+        w.writerow([raw_text(v) for v in row])
+    return buf.getvalue().rstrip("\n")
+
+
+def md_cell(v: Any) -> str:
+    return raw_text(v).replace("|", "\\|").replace("\r\n", "<br>").replace("\n", "<br>")
+
+
+def to_markdown(rows: Sequence[Row], header: Sequence[str]) -> str:
+    lines = ["| " + " | ".join(md_cell(h) for h in header) + " |"]
+    lines.append("| " + " | ".join("---" for _ in header) + " |")
+    lines += ["| " + " | ".join(md_cell(v) for v in row) + " |" for row in rows]
+    return "\n".join(lines)
+
+
+def json_default(v: Any) -> Any:
+    if isinstance(v, Decimal):
+        return int(v) if v == v.to_integral_value() else float(v)
+    if isinstance(v, dt.datetime):
+        return v.isoformat(sep=" ")
+    if isinstance(v, dt.date | dt.time):
+        return v.isoformat()
+    if isinstance(v, bytes):
+        return "0x" + v.hex()
+    return str(v)
+
+
+def to_json(rows: Sequence[Row], header: Sequence[str]) -> str:
+    objs = [dict(zip(header, row, strict=True)) for row in rows]
+    return json.dumps(objs, default=json_default, ensure_ascii=False, indent=2)
+
+
+def sql_literal(v: Any) -> str:
+    if v is None:
+        return "NULL"
+    if isinstance(v, bool):
+        return "TRUE" if v else "FALSE"
+    if isinstance(v, int | Decimal):
+        return raw_text(v)
+    if isinstance(v, float):
+        return repr(v)
+    if isinstance(v, bytes):
+        return f"X'{v.hex()}'"
+    return "'" + raw_text(v).replace("'", "''") + "'"
+
+
+def sql_ident(name: str) -> str:
+    return name if _PLAIN_IDENT.match(name) else '"' + name.replace('"', '""') + '"'
+
+
+def to_insert_sql(rows: Sequence[Row], header: Sequence[str], table: str = "table_name") -> str:
+    cols = ", ".join(sql_ident(h) for h in header)
+    return "\n".join(
+        f"INSERT INTO {table} ({cols}) VALUES ({', '.join(sql_literal(v) for v in row)});"
+        for row in rows
+    )

sqlide/grid/formatting.py

@@ -0,0 +1,43 @@
+"""Human-readable cell text. The only place that decides how a value looks."""
+
+from __future__ import annotations
+
+import datetime as dt
+from decimal import Decimal
+from typing import Any
+
+NULL_TEXT = "<null>"
+_BYTES_PREVIEW = 16
+
+
+def format_value(v: Any) -> str:
+    if v is None:
+        return NULL_TEXT
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, bytes):
+        head = v[:_BYTES_PREVIEW].hex()
+        return f"0x{head}" + (f"… ({len(v)} bytes)" if len(v) > _BYTES_PREVIEW else "")
+    if isinstance(v, dt.datetime):
+        text = v.isoformat(sep=" ")
+        return text
+    if isinstance(v, Decimal):
+        return format(v, "f")
+    if isinstance(v, float):
+        return repr(v)
+    return str(v).replace("\r\n", "⏎").replace("\n", "⏎").replace("\t", "⇥")
+
+
+def raw_text(v: Any) -> str:
+    """Full-fidelity text for copy/export: no truncation, NULL is empty."""
+    if v is None:
+        return ""
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, bytes):
+        return "0x" + v.hex()
+    if isinstance(v, dt.datetime):
+        return v.isoformat(sep=" ")
+    if isinstance(v, Decimal):
+        return format(v, "f")
+    return str(v)

sqlide/grid/model.py

@@ -0,0 +1,109 @@
+"""Table state behind the result grid: rows, multi-column sort, filter, paging. Pure Python."""
+
+from __future__ import annotations
+
+import datetime as dt
+from collections.abc import Iterable, Sequence
+from decimal import Decimal
+from typing import Any
+
+from sqlide.db.result import Column
+from sqlide.grid.formatting import format_value
+
+Row = tuple[Any, ...]
+
+
+def _sort_key(v: Any) -> tuple[int, Any]:
+    """Orders values of mixed types without ever raising (NULLs are handled by the caller)."""
+    if isinstance(v, bool | int | float | Decimal):
+        return (0, v if v == v else float("-inf"))  # NaN sorts first
+    if isinstance(v, dt.datetime):
+        return (1, v)
+    if isinstance(v, dt.date):
+        return (2, v)
+    if isinstance(v, dt.time):
+        return (3, v)
+    if isinstance(v, bytes):
+        return (4, v)
+    return (5, str(v).casefold())
+
+
+class GridModel:
+    def __init__(self, columns: Sequence[Column], rows: Iterable[Row] = ()) -> None:
+        self.columns = list(columns)
+        self._rows: list[Row] = list(rows)
+        self._view: list[int] = list(range(len(self._rows)))
+        self._search: list[str | None] = [None] * len(self._rows)
+        self.sort: list[tuple[int, bool]] = []  # (column, descending), most significant first
+        self.filter_text = ""
+
+    # --- reading ---
+    def __len__(self) -> int:
+        return len(self._view)
+
+    @property
+    def total_rows(self) -> int:
+        return len(self._rows)
+
+    def row(self, view_row: int) -> Row:
+        return self._rows[self._view[view_row]]
+
+    def value(self, view_row: int, col: int) -> Any:
+        return self._rows[self._view[view_row]][col]
+
+    def rows(self, first: int, last: int) -> list[Row]:
+        """View rows first..last inclusive."""
+        return [self._rows[i] for i in self._view[first : last + 1]]
+
+    # --- changing ---
+    def append(self, rows: Sequence[Row]) -> None:
+        start = len(self._rows)
+        self._rows.extend(rows)
+        self._search.extend([None] * len(rows))
+        if self.sort or self.filter_text:
+            self._rebuild()
+        else:
+            self._view.extend(range(start, len(self._rows)))
+
+    def set_filter(self, text: str) -> None:
+        self.filter_text = text.strip()
+        self._rebuild()
+
+    def cycle_sort(self, col: int, add: bool = False) -> None:
+        """none -> ascending -> descending -> none. `add` keeps other sort columns."""
+        current = dict(self.sort).get(col)
+        new = {None: False, False: True, True: None}[current]
+        others = [(c, d) for c, d in self.sort if c != col] if add else []
+        if new is None:
+            self.sort = others
+        elif add and current is not None:
+            self.sort = [(c, new if c == col else d) for c, d in self.sort]
+        else:
+            self.sort = [*others, (col, new)]
+        self._rebuild()
+
+    def sort_state(self, col: int) -> tuple[bool, int] | None:
+        """(descending, 1-based priority) or None if the column is not sorted."""
+        for rank, (c, desc) in enumerate(self.sort, 1):
+            if c == col:
+                return desc, rank
+        return None
+
+    # --- internals ---
+    def _matches(self, i: int, needle: str) -> bool:
+        text = self._search[i]
+        if text is None:
+            text = self._search[i] = "\x00".join(format_value(v).lower() for v in self._rows[i])
+        return needle in text
+
+    def _rebuild(self) -> None:
+        idx = list(range(len(self._rows)))
+        if self.filter_text:
+            needle = self.filter_text.lower()
+            idx = [i for i in idx if self._matches(i, needle)]
+        for col, desc in reversed(self.sort):  # stable sorts, least significant key first
+            present = [i for i in idx if self._rows[i][col] is not None]
+            nulls = [i for i in idx if self._rows[i][col] is None]
+            present.sort(key=lambda i, c=col: _sort_key(self._rows[i][c]), reverse=desc)
+            idx = present + nulls  # NULLs last in both directions
+        self._view = idx

sqlide/history/__init__.py

@@ -0,0 +1,5 @@
+"""Query history (sqlite). Depends only on config paths."""
+
+from sqlide.history.store import HistoryEntry, HistoryStore
+
+__all__ = ["HistoryEntry", "HistoryStore"]

sqlide/history/store.py

@@ -0,0 +1,117 @@
+"""Persistent log of executed statements."""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from sqlide.config import paths
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts REAL NOT NULL,
+    connection TEXT NOT NULL,
+    sql TEXT NOT NULL,
+    ok INTEGER NOT NULL,
+    elapsed_ms INTEGER NOT NULL,
+    error TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS history_ts ON history (ts DESC);
+"""
+
+
+@dataclass(frozen=True, slots=True)
+class HistoryEntry:
+    id: int
+    ts: float
+    connection: str
+    sql: str
+    ok: bool
+    elapsed_ms: int
+    error: str = ""
+
+
+def _like(word: str) -> str:
+    return "%" + word.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
+
+
+class HistoryStore:
+    """Opens its file on first use. Call from one thread (the UI thread)."""
+
+    def __init__(self, path: Path | None = None, limit: int = 5000) -> None:
+        self._path = path
+        self.limit = limit
+        self._db: sqlite3.Connection | None = None
+
+    def _conn(self) -> sqlite3.Connection:
+        if self._db is None:
+            path = self._path or paths.data_dir() / "history.sqlite"
+            path.parent.mkdir(parents=True, exist_ok=True)
+            self._db = sqlite3.connect(path)
+            self._db.executescript(_SCHEMA)
+        return self._db
+
+    def add(
+        self,
+        connection: str,
+        sql: str,
+        ok: bool,
+        elapsed_ms: int,
+        error: str = "",
+        ts: float | None = None,
+    ) -> None:
+        sql = sql.strip()
+        if not sql:
+            return
+        db = self._conn()
+        db.execute(
+            "INSERT INTO history (ts, connection, sql, ok, elapsed_ms, error) VALUES (?,?,?,?,?,?)",
+            (time.time() if ts is None else ts, connection, sql, int(ok), elapsed_ms, error),
+        )
+        db.execute(
+            "DELETE FROM history WHERE id <= (SELECT MAX(id) FROM history) - ?", (self.limit,)
+        )
+        db.commit()
+
+    def search(
+        self,
+        text: str = "",
+        connection: str | None = None,
+        only_ok: bool = False,
+        limit: int = 200,
+    ) -> list[HistoryEntry]:
+        """Newest first. Every word of `text` must occur in the statement (case-insensitive)."""
+        where, args = [], []
+        for word in text.split():
+            where.append("sql LIKE ? ESCAPE '\\'")
+            args.append(_like(word))
+        if connection is not None:
+            where.append("connection = ?")
+            args.append(connection)
+        if only_ok:
+            where.append("ok = 1")
+        clause = ("WHERE " + " AND ".join(where)) if where else ""
+        rows = self._conn().execute(
+            "SELECT id, ts, connection, sql, ok, elapsed_ms, error FROM history "
+            f"{clause} ORDER BY id DESC LIMIT ?",
+            (*args, limit),
+        )
+        return [HistoryEntry(r[0], r[1], r[2], r[3], bool(r[4]), r[5], r[6]) for r in rows]
+
+    def delete(self, entry_id: int) -> None:
+        db = self._conn()
+        db.execute("DELETE FROM history WHERE id = ?", (entry_id,))
+        db.commit()
+
+    def clear(self) -> None:
+        db = self._conn()
+        db.execute("DELETE FROM history")
+        db.commit()
+
+    def close(self) -> None:
+        if self._db is not None:
+            self._db.close()
+            self._db = None

sqlide/jvm/__init__.py

@@ -0,0 +1 @@
+"""JVM block: locate a Java runtime and start it once inside this process."""

sqlide/jvm/locate.py

@@ -0,0 +1,98 @@
+"""Find a usable JVM (Java 11+). Pure Python, does not start anything."""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+MIN_JAVA = 11
+
+INSTALL_HINT = (
+    "Java 11+ not found. Install one:\n"
+    "  macOS:  brew install openjdk\n"
+    "  Debian/Ubuntu/WSL:  sudo apt install openjdk-21-jre-headless\n"
+    "  or set JAVA_HOME to an existing JDK/JRE."
+)
+
+
+class JvmNotFound(Exception):
+    """No suitable JVM on this machine; str(e) is a user-facing hint."""
+
+
+@dataclass(frozen=True, slots=True)
+class JvmInfo:
+    home: Path
+    libjvm: Path
+    major: int
+
+
+def _libjvm(home: Path) -> Path | None:
+    names = {"darwin": ("libjvm.dylib",), "win32": ("jvm.dll",)}.get(sys.platform, ("libjvm.so",))
+    for sub in ("lib/server", "bin/server", "jre/lib/server"):
+        for n in names:
+            p = home / sub / n
+            if p.is_file():
+                return p
+    return None
+
+
+def _major(home: Path) -> int | None:
+    """Parse JAVA_VERSION from the `release` file: '21.0.1' -> 21, '1.8.0_1' -> 8."""
+    try:
+        text = (home / "release").read_text()
+    except OSError:
+        return None
+    m = re.search(r'JAVA_VERSION="?(\d+)(?:\.(\d+))?', text)
+    if not m:
+        return None
+    first, second = int(m.group(1)), m.group(2)
+    return int(second) if first == 1 and second else first
+
+
+def _candidates() -> list[Path]:
+    out: list[Path] = []
+    if env := os.environ.get("JAVA_HOME"):
+        out.append(Path(env))
+    if java := shutil.which("java"):
+        out.append(Path(java).resolve().parent.parent)
+    if sys.platform == "darwin":
+        try:
+            r = subprocess.run(
+                ["/usr/libexec/java_home"], capture_output=True, text=True, timeout=5
+            )
+            if r.returncode == 0 and r.stdout.strip():
+                out.append(Path(r.stdout.strip()))
+        except (OSError, subprocess.SubprocessError):
+            pass
+        # Homebrew's openjdk is keg-only: the JDK sits under libexec, and is not on PATH
+        for prefix in (Path("/opt/homebrew/opt/openjdk"), Path("/usr/local/opt/openjdk")):
+            out += [prefix / "libexec/openjdk.jdk/Contents/Home", prefix]
+    elif sys.platform.startswith("linux"):
+        out += [Path("/home/linuxbrew/.linuxbrew/opt/openjdk")]
+    return out
+
+
+def locate_jvm() -> JvmInfo:
+    """First candidate that has a libjvm and is Java >= MIN_JAVA."""
+    seen: set[Path] = set()
+    too_old: list[str] = []
+    for home in _candidates():
+        if home in seen:
+            continue
+        seen.add(home)
+        lib, major = _libjvm(home), _major(home)
+        if lib is None:
+            continue
+        if major is not None and major < MIN_JAVA:
+            too_old.append(f"{home} (Java {major})")
+            continue
+        return JvmInfo(home=home, libjvm=lib, major=major or 0)
+    msg = INSTALL_HINT
+    if too_old:
+        msg = f"Found only too old Java: {', '.join(too_old)}.\n{msg}"
+    raise JvmNotFound(msg)

sqlide/jvm/runtime.py

@@ -0,0 +1,44 @@
+"""Start the in-process JVM exactly once (JPype cannot restart it)."""
+
+from __future__ import annotations
+
+import threading
+
+import jpype
+import jpype.config
+
+from sqlide.jvm.locate import JvmInfo, locate_jvm
+
+_lock = threading.Lock()
+_info: JvmInfo | None = None
+
+
+def ensure_jvm() -> JvmInfo:
+    """Idempotent and thread-safe. Raises JvmNotFound with an install hint."""
+    global _info
+    with _lock:
+        if _info is not None:
+            return _info
+        info = locate_jvm()
+        if not jpype.isJVMStarted():
+            # We start the JVM from worker threads; DestroyJavaVM at interpreter exit then
+            # hangs. Sessions are closed explicitly, so skipping the JVM teardown loses nothing.
+            jpype.config.destroy_jvm = False
+            jpype.startJVM(str(info.libjvm), "-Djava.awt.headless=true", convertStrings=False)
+            _silence_jvm_streams()
+        _info = info
+        return info
+
+
+def jvm_started() -> bool:
+    return jpype.isJVMStarted()
+
+
+def _silence_jvm_streams() -> None:
+    """Drivers (SLF4J etc.) print straight to the JVM's fd 1/2, which would corrupt the TUI."""
+    System = jpype.JClass("java.lang.System")
+    sink = jpype.JClass("java.io.PrintStream")(
+        jpype.JClass("java.io.OutputStream").nullOutputStream()
+    )
+    System.setOut(sink)
+    System.setErr(sink)

sqlide/sql/__init__.py

@@ -0,0 +1 @@
+"""SQL block: pure-Python lexer and statement splitter. No JVM, no UI."""