sqlide 0.1.0__py3-none-any.whl

sqlide/drivers/custom.py

@@ -0,0 +1,69 @@
+"""Build and validate a user-defined driver (shared by the CLI and the driver manager UI)."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from sqlide.config._toml import ConfigError
+from sqlide.drivers.loader import DriverError, scan_driver_classes
+from sqlide.drivers.registry import DriverDef
+
+_ID = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
+
+
+def parse_maven(coords: str) -> tuple[str, str, list[str]]:
+    """'group:artifact[:classifier]' -> (group, artifact, classifiers)."""
+    parts = [p.strip() for p in coords.split(":")]
+    if len(parts) not in (2, 3) or not all(parts[:2]):
+        raise ConfigError("Maven coordinates: group:artifact[:classifier]")
+    return parts[0], parts[1], [parts[2] if len(parts) == 3 else ""]
+
+
+def build_custom_driver(
+    id: str,
+    name: str = "",
+    *,
+    maven: str = "",
+    jars: list[str] | None = None,
+    class_name: str = "",
+    url_template: str = "",
+    default_port: int = 0,
+    dialect: str = "generic",
+) -> DriverDef:
+    """Validate the pieces. Jars are checked on disk and the driver class is detected from them."""
+    id = id.strip()
+    if not _ID.match(id):
+        raise ConfigError("Id: lowercase letters, digits, '-' and '_'")
+    jars = [j.strip() for j in (jars or []) if j.strip()]
+    if bool(maven.strip()) == bool(jars):
+        raise ConfigError("Give either Maven coordinates or jar files")
+    group = artifact = ""
+    classifiers = [""]
+    if maven.strip():
+        group, artifact, classifiers = parse_maven(maven)
+    resolved = [Path(j).expanduser() for j in jars]
+    for j in resolved:
+        if not j.is_file():
+            raise ConfigError(f"No such jar: {j}")
+    class_name = class_name.strip()
+    if resolved and not class_name:
+        try:
+            found = scan_driver_classes(resolved)
+        except DriverError as e:
+            raise ConfigError(str(e)) from e
+        if not found:
+            raise ConfigError("No JDBC driver found in the jars: enter the driver class")
+        class_name = found[0]
+    return DriverDef(
+        id=id,
+        name=name.strip() or id,
+        class_name=class_name,
+        url_template=url_template.strip(),
+        default_port=default_port,
+        dialect=dialect,
+        group=group,
+        artifact=artifact,
+        classifiers=classifiers,
+        jars=[str(j) for j in resolved],
+    )

sqlide/drivers/loader.py

@@ -0,0 +1,75 @@
+"""Load a JDBC driver through its own URLClassLoader (no DriverManager, no global state)."""
+
+from __future__ import annotations
+
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from sqlide.drivers.registry import DriverDef
+from sqlide.jvm.runtime import ensure_jvm
+
+SERVICE_FILE = "META-INF/services/java.sql.Driver"
+
+
+class DriverError(Exception):
+    pass
+
+
+def scan_driver_classes(jars: list[Path]) -> list[str]:
+    """Driver classes declared in the jars. Pure zip read, JVM not needed."""
+    found: list[str] = []
+    for jar in jars:
+        try:
+            with zipfile.ZipFile(jar) as z:
+                if SERVICE_FILE in z.namelist():
+                    for line in z.read(SERVICE_FILE).decode("utf-8", "replace").splitlines():
+                        line = line.split("#", 1)[0].strip()
+                        if line and line not in found:
+                            found.append(line)
+        except (OSError, zipfile.BadZipFile) as e:
+            raise DriverError(f"{jar}: {e}") from e
+    return found
+
+
+@dataclass(frozen=True, slots=True)
+class LoadedDriver:
+    driver: Any  # java.sql.Driver
+    loader: Any  # java.net.URLClassLoader, set as thread context loader by sessions
+
+
+_cache: dict[tuple[str, ...], LoadedDriver] = {}
+
+
+def load_driver(defn: DriverDef, jars: list[Path]) -> LoadedDriver:
+    if not jars:
+        raise DriverError(f"driver '{defn.id}' has no jars; run: sqlide driver install {defn.id}")
+    key = (defn.class_name, *map(str, jars))
+    if key in _cache:
+        return _cache[key]
+
+    class_name = defn.class_name
+    if not class_name:
+        classes = scan_driver_classes(jars)
+        if len(classes) != 1:
+            raise DriverError(
+                f"driver '{defn.id}': cannot pick class automatically, candidates: {classes}"
+            )
+        class_name = classes[0]
+
+    ensure_jvm()
+    import jpype  # deferred: JVM must be up before JClass lookups
+
+    File, URL = jpype.JClass("java.io.File"), jpype.JClass("java.net.URL")
+    jarray: Any = jpype.JArray  # JPype stubs type this too narrowly
+    urls = jarray(URL)([File(str(j)).toURI().toURL() for j in jars])
+    parent = jpype.JClass("java.lang.ClassLoader").getSystemClassLoader()
+    loader = jpype.JClass("java.net.URLClassLoader")(urls, parent)
+    try:
+        cls = jpype.JClass("java.lang.Class").forName(class_name, True, loader)
+        driver = cls.getDeclaredConstructor().newInstance()
+    except Exception as e:  # java exceptions surface as Python exceptions in JPype
+        raise DriverError(f"cannot load {class_name}: {e}") from e
+    _cache[key] = LoadedDriver(driver, loader)
+    return _cache[key]

sqlide/drivers/maven.py

@@ -0,0 +1,108 @@
+"""Maven Central client: pick latest stable version, download jar, verify sha1."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import xml.etree.ElementTree as ET
+from collections.abc import Callable
+from pathlib import Path
+
+import httpx
+
+BASE_URL = os.environ.get("SQLIDE_MAVEN_URL", "https://repo1.maven.org/maven2")
+
+Progress = Callable[[int, int | None], None]  # (bytes_done, total_or_None)
+
+_PRE = re.compile(r"^(alpha|beta|rc|cr|m|b|ea|dev|preview|snapshot)\d*$", re.I)
+
+
+class MavenError(Exception):
+    pass
+
+
+def _tokens(version: str) -> list[str]:
+    return [t for t in re.split(r"[.\-_]", version) if t]
+
+
+def is_stable(version: str) -> bool:
+    return not any(_PRE.match(t) for t in _tokens(version))
+
+
+def version_key(version: str) -> tuple:
+    """Sortable key: numeric tokens compare as numbers and rank above text tokens."""
+    return tuple((1, int(t), "") if t.isdigit() else (0, 0, t) for t in _tokens(version))
+
+
+def pick_latest(versions: list[str], suffix: str = "") -> str:
+    pool = [v for v in versions if is_stable(v) and v.endswith(suffix)]
+    if not pool:
+        raise MavenError("no stable versions found")
+    return max(pool, key=version_key)
+
+
+def jar_name(artifact: str, version: str, classifier: str) -> str:
+    return f"{artifact}-{version}" + (f"-{classifier}" if classifier else "") + ".jar"
+
+
+class MavenClient:
+    def __init__(self, client: httpx.Client | None = None, base_url: str = BASE_URL) -> None:
+        self._client = client or httpx.Client(timeout=30, follow_redirects=True)
+        self._base = base_url.rstrip("/")
+
+    def _dir(self, group: str, artifact: str) -> str:
+        return f"{self._base}/{group.replace('.', '/')}/{artifact}"
+
+    def versions(self, group: str, artifact: str) -> list[str]:
+        url = f"{self._dir(group, artifact)}/maven-metadata.xml"
+        r = self._client.get(url)
+        if r.status_code != 200:
+            raise MavenError(f"{url}: HTTP {r.status_code}")
+        return [v.text or "" for v in ET.fromstring(r.text).iter("version")]
+
+    def latest(self, group: str, artifact: str, suffix: str = "") -> str:
+        return pick_latest(self.versions(group, artifact), suffix)
+
+    def find_jar_url(
+        self, group: str, artifact: str, version: str, classifiers: list[str]
+    ) -> tuple[str, str]:
+        """First classifier whose jar exists -> (url, file name)."""
+        for c in classifiers or [""]:
+            name = jar_name(artifact, version, c)
+            url = f"{self._dir(group, artifact)}/{version}/{name}"
+            if self._client.head(url).status_code == 200:
+                return url, name
+        raise MavenError(f"{group}:{artifact}:{version}: no jar for classifiers {classifiers}")
+
+    def download(self, url: str, dest: Path, progress: Progress | None = None) -> Path:
+        """Stream to a temp file, verify against <url>.sha1, then rename into place."""
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        tmp = dest.with_name(dest.name + ".part")
+        sha = hashlib.sha1()
+        try:
+            with self._client.stream("GET", url) as r:
+                if r.status_code != 200:
+                    raise MavenError(f"{url}: HTTP {r.status_code}")
+                total = int(r.headers["content-length"]) if "content-length" in r.headers else None
+                done = 0
+                with tmp.open("wb") as f:
+                    for chunk in r.iter_bytes(65536):
+                        f.write(chunk)
+                        sha.update(chunk)
+                        done += len(chunk)
+                        if progress:
+                            progress(done, total)
+            self._verify(url, sha.hexdigest())
+            os.replace(tmp, dest)
+        finally:
+            tmp.unlink(missing_ok=True)
+        return dest
+
+    def _verify(self, url: str, actual: str) -> None:
+        r = self._client.get(url + ".sha1")
+        if r.status_code != 200:
+            raise MavenError(f"{url}.sha1: HTTP {r.status_code}, cannot verify")
+        expected = r.text.split()[0].strip().lower() if r.text.strip() else ""
+        if expected != actual:
+            raise MavenError(f"sha1 mismatch for {url}: expected {expected}, got {actual}")

sqlide/drivers/registry.py

@@ -0,0 +1,117 @@
+"""Driver definitions (built-in catalog + user drivers.toml) and what is installed on disk."""
+
+from __future__ import annotations
+
+import shutil
+import tomllib
+from collections.abc import Callable
+from dataclasses import dataclass, field, fields
+from importlib import resources
+from pathlib import Path
+
+from sqlide.config import paths
+from sqlide.config._toml import ConfigError, read_toml, write_toml
+from sqlide.drivers.maven import MavenClient, MavenError, version_key
+
+
+@dataclass(slots=True)
+class DriverDef:
+    id: str
+    name: str
+    class_name: str = ""  # empty = detect from META-INF/services in the jars
+    url_template: str = ""
+    default_port: int = 0
+    dialect: str = "generic"
+    group: str = ""  # Maven coordinates (downloadable driver)...
+    artifact: str = ""
+    classifiers: list[str] = field(default_factory=lambda: [""])
+    version_suffix: str = ""
+    jars: list[str] = field(default_factory=list)  # ...or local jar paths (custom driver)
+
+    @property
+    def is_maven(self) -> bool:
+        return bool(self.group and self.artifact)
+
+
+def _from_dict(raw: dict, origin: str) -> DriverDef:
+    known = {f.name for f in fields(DriverDef)}
+    if extra := set(raw) - known:
+        raise ConfigError(f"{origin}: unknown driver keys {sorted(extra)}")
+    try:
+        d = DriverDef(**raw)
+    except TypeError as e:
+        raise ConfigError(f"{origin}: {e}") from e
+    if not d.is_maven and not d.jars:
+        raise ConfigError(f"{origin}: driver '{d.id}' needs group+artifact or jars")
+    return d
+
+
+def _builtin() -> dict[str, DriverDef]:
+    text = resources.files("sqlide.drivers").joinpath("catalog.toml").read_text("utf-8")
+    items = tomllib.loads(text)["driver"]
+    return {d["id"]: _from_dict(d, "catalog.toml") for d in items}
+
+
+class DriverRegistry:
+    def __init__(self, drivers_dir: Path | None = None, user_file: Path | None = None) -> None:
+        self.dir = drivers_dir or paths.drivers_dir()
+        self.user_file = user_file or paths.drivers_file()
+
+    # --- definitions ---
+    def _user(self) -> dict[str, DriverDef]:
+        items = read_toml(self.user_file).get("driver", [])
+        return {d["id"]: _from_dict(d, str(self.user_file)) for d in items if "id" in d}
+
+    def all(self) -> dict[str, DriverDef]:
+        return {**_builtin(), **self._user()}  # user entry overrides built-in by id
+
+    def get(self, driver_id: str) -> DriverDef:
+        try:
+            return self.all()[driver_id]
+        except KeyError:
+            raise ConfigError(f"unknown driver '{driver_id}'") from None
+
+    def add_custom(self, d: DriverDef) -> None:
+        _from_dict({f.name: getattr(d, f.name) for f in fields(d)}, "new driver")  # validate
+        users = {**self._user(), d.id: d}
+        write_toml(
+            self.user_file,
+            {"driver": [{f.name: getattr(u, f.name) for f in fields(u)} for u in users.values()]},
+        )
+
+    # --- disk state ---
+    def installed_versions(self, driver_id: str) -> list[str]:
+        root = self.dir / driver_id
+        if not root.is_dir():
+            return []
+        vs = [p.name for p in root.iterdir() if p.is_dir() and any(p.glob("*.jar"))]
+        return sorted(vs, key=version_key)
+
+    def jar_paths(self, driver_id: str) -> list[Path]:
+        d = self.get(driver_id)
+        if d.jars:
+            return [Path(j).expanduser() for j in d.jars if Path(j).expanduser().is_file()]
+        versions = self.installed_versions(driver_id)
+        return sorted((self.dir / driver_id / versions[-1]).glob("*.jar")) if versions else []
+
+    def is_installed(self, driver_id: str) -> bool:
+        return bool(self.jar_paths(driver_id))
+
+    # --- install ---
+    def install(
+        self,
+        driver_id: str,
+        maven: MavenClient | None = None,
+        version: str | None = None,
+        progress: Callable[[int, int | None], None] | None = None,
+    ) -> Path:
+        d = self.get(driver_id)
+        if not d.is_maven:
+            raise MavenError(f"driver '{driver_id}' is local-jar only, nothing to download")
+        maven = maven or MavenClient()
+        version = version or maven.latest(d.group, d.artifact, d.version_suffix)
+        url, name = maven.find_jar_url(d.group, d.artifact, version, d.classifiers)
+        return maven.download(url, self.dir / driver_id / version / name, progress)
+
+    def uninstall(self, driver_id: str) -> None:
+        shutil.rmtree(self.dir / driver_id, ignore_errors=True)

sqlide/export/__init__.py

@@ -0,0 +1,12 @@
+"""Export block: pluggable file formats. Importing the package registers all of them."""
+
+from sqlide.export import csv_, html, json_, markdown, sql_insert, xlsx  # noqa: F401
+from sqlide.export.base import (
+    ExportCancelled,
+    Exporter,
+    ExportOptions,
+    all_exporters,
+    get,
+)
+
+__all__ = ["ExportCancelled", "ExportOptions", "Exporter", "all_exporters", "get"]

sqlide/export/base.py

@@ -0,0 +1,86 @@
+"""Exporter contract, options, registry. Formats live in sibling modules, one file each."""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable, Iterator, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from sqlide.db.result import Column
+
+Row = tuple[Any, ...]
+PROGRESS_EVERY = 1000
+
+
+class ExportCancelled(Exception):
+    pass
+
+
+@dataclass(slots=True)
+class ExportOptions:
+    header: bool = True
+    delimiter: str = ","  # csv
+    bom: bool = False  # csv: UTF-8 BOM, makes Excel pick the right encoding
+    table_name: str = "table_name"  # sql insert
+    batch_size: int = 1  # sql insert: rows per INSERT
+    sheet_name: str = "Result"  # xlsx
+    progress: Callable[[int], None] | None = None  # rows written so far
+    should_cancel: Callable[[], bool] | None = None
+
+
+class Exporter(ABC):
+    name: str  # registry key, e.g. "csv"
+    label: str  # shown in the UI
+    extension: str  # with dot
+
+    def write(
+        self, columns: Sequence[Column], rows: Iterable[Row], path: Path, opts: ExportOptions
+    ) -> int:
+        """Write all rows to `path` atomically. Returns the number of rows written."""
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(f".{path.name}.part")
+        try:
+            count = self._write(list(columns), tracked(rows, opts), tmp, opts)
+            os.replace(tmp, path)
+            return count
+        finally:
+            tmp.unlink(missing_ok=True)
+
+    @abstractmethod
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int: ...
+
+
+def tracked(rows: Iterable[Row], opts: ExportOptions) -> Iterator[Row]:
+    """Wrap the row stream: progress callbacks and cooperative cancellation."""
+    for n, row in enumerate(rows, 1):
+        if opts.should_cancel is not None and opts.should_cancel():
+            raise ExportCancelled()
+        yield row
+        if opts.progress is not None and n % PROGRESS_EVERY == 0:
+            opts.progress(n)
+
+
+_REGISTRY: dict[str, Exporter] = {}
+
+
+def register(cls: type[Exporter]) -> type[Exporter]:
+    inst = cls()
+    _REGISTRY[inst.name] = inst
+    return cls
+
+
+def get(name: str) -> Exporter:
+    try:
+        return _REGISTRY[name]
+    except KeyError:
+        raise KeyError(f"unknown export format '{name}'") from None
+
+
+def all_exporters() -> list[Exporter]:
+    return list(_REGISTRY.values())

sqlide/export/csv_.py

@@ -0,0 +1,40 @@
+"""CSV and TSV."""
+
+from __future__ import annotations
+
+import csv
+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.formatting import raw_text
+
+
+class _Delimited(Exporter):
+    forced_delimiter: str | None = None
+
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int:
+        delimiter = self.forced_delimiter or opts.delimiter or ","
+        count = 0
+        with tmp.open("w", encoding="utf-8-sig" if opts.bom else "utf-8", newline="") as f:
+            w = csv.writer(f, delimiter=delimiter, lineterminator="\n")
+            if opts.header:
+                w.writerow([c.name for c in columns])
+            for row in rows:
+                w.writerow([raw_text(v) for v in row])
+                count += 1
+        return count
+
+
+@register
+class CsvExporter(_Delimited):
+    name, label, extension = "csv", "CSV", ".csv"
+
+
+@register
+class TsvExporter(_Delimited):
+    name, label, extension = "tsv", "TSV (tab separated)", ".tsv"
+    forced_delimiter = "\t"

sqlide/export/html.py

@@ -0,0 +1,44 @@
+"""Standalone HTML table."""
+
+from __future__ import annotations
+
+import html
+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.formatting import raw_text
+
+_HEAD = (
+    '<!doctype html>\n<meta charset="utf-8">\n<style>'
+    "table{border-collapse:collapse;font:14px sans-serif}"
+    "th,td{border:1px solid #ccc;padding:4px 8px;text-align:left}"
+    "th{background:#f0f0f0}td.null{background:#fafafa}"
+    "</style>\n<table>\n"
+)
+
+
+@register
+class HtmlExporter(Exporter):
+    name, label, extension = "html", "HTML table", ".html"
+
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int:
+        count = 0
+        with tmp.open("w", encoding="utf-8") as f:
+            f.write(_HEAD)
+            f.write("<thead><tr>" + "".join(f"<th>{html.escape(c.name)}</th>" for c in columns))
+            f.write("</tr></thead>\n<tbody>\n")
+            for row in rows:
+                cells = (
+                    '<td class="null"></td>'
+                    if v is None
+                    else f"<td>{html.escape(raw_text(v))}</td>"
+                    for v in row
+                )
+                f.write("<tr>" + "".join(cells) + "</tr>\n")
+                count += 1
+            f.write("</tbody>\n</table>\n")
+        return count

sqlide/export/json_.py

@@ -0,0 +1,47 @@
+"""JSON array and JSON Lines, streamed row by row."""
+
+from __future__ import annotations
+
+import json
+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 json_default
+
+
+def _dump(names: list[str], row: Row) -> str:
+    return json.dumps(dict(zip(names, row, strict=True)), default=json_default, ensure_ascii=False)
+
+
+@register
+class JsonExporter(Exporter):
+    name, label, extension = "json", "JSON (array)", ".json"
+
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int:
+        names, count = [c.name for c in columns], 0
+        with tmp.open("w", encoding="utf-8") as f:
+            f.write("[")
+            for row in rows:
+                f.write(("," if count else "") + "\n  " + _dump(names, row))
+                count += 1
+            f.write("\n]\n" if count else "]\n")
+        return count
+
+
+@register
+class JsonLinesExporter(Exporter):
+    name, label, extension = "jsonl", "JSON Lines", ".jsonl"
+
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int:
+        names, count = [c.name for c in columns], 0
+        with tmp.open("w", encoding="utf-8") as f:
+            for row in rows:
+                f.write(_dump(names, row) + "\n")
+                count += 1
+        return count

sqlide/export/markdown.py

@@ -0,0 +1,27 @@
+"""Markdown table."""
+
+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 md_cell
+
+
+@register
+class MarkdownExporter(Exporter):
+    name, label, extension = "markdown", "Markdown table", ".md"
+
+    def _write(
+        self, columns: list[Column], rows: Iterator[Row], tmp: Path, opts: ExportOptions
+    ) -> int:
+        count = 0
+        with tmp.open("w", encoding="utf-8") as f:
+            f.write("| " + " | ".join(md_cell(c.name) for c in columns) + " |\n")
+            f.write("| " + " | ".join("---" for _ in columns) + " |\n")
+            for row in rows:
+                f.write("| " + " | ".join(md_cell(v) for v in row) + " |\n")
+                count += 1
+        return count

sqlide/export/service.py

@@ -0,0 +1,34 @@
+"""Run an export for each data scope. Blocking work happens off the UI thread."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Sequence
+from pathlib import Path
+
+from sqlide.db.result import Column
+from sqlide.db.session import DbSession
+from sqlide.export.base import Exporter, ExportOptions, Row
+
+
+async def export_rows(
+    exporter: Exporter,
+    columns: Sequence[Column],
+    rows: Sequence[Row],
+    path: Path,
+    opts: ExportOptions,
+) -> int:
+    """Rows already in memory (grid view or selection)."""
+    return await asyncio.to_thread(exporter.write, columns, rows, path, opts)
+
+
+async def export_query(
+    exporter: Exporter, session: DbSession, sql: str, path: Path, opts: ExportOptions
+) -> int:
+    """Re-run `sql` on `session` and stream the whole first result set into the file.
+
+    Use a dedicated session: running a statement closes the session's open cursors.
+    """
+    return await session.stream(
+        sql, lambda columns, rows: exporter.write(columns, rows, path, opts)
+    )