sqlide 0.1.0__py3-none-any.whl

sqlide/db/completion.py

@@ -0,0 +1,127 @@
+"""Autocomplete candidates: a Context (what is typed) + MetaCache (what exists) + keywords."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from sqlide.db.metadata import MetaCache, Namespace, Table
+from sqlide.db.result import DbError
+from sqlide.sql.context import Context
+from sqlide.sql.keywords import functions, keywords
+from sqlide.sql.snippets import quote_ident
+
+MAX_CANDIDATES = 60
+
+
+@dataclass(frozen=True, slots=True)
+class Candidate:
+    text: str  # what gets inserted (already quoted when needed)
+    kind: str  # column | table | view | schema | keyword | function
+    detail: str = ""
+
+
+def _same(a: str, b: str) -> bool:
+    return a.lower() == b.lower()
+
+
+async def _find_namespace(meta: MetaCache, name: str) -> Namespace | None:
+    return next((n for n in await meta.namespaces() if _same(n.name, name)), None)
+
+
+async def _resolve(meta: MetaCache, ref_parts: tuple[str, ...]) -> Table | None:
+    """Table named by `ref_parts` ((table,) or (schema, table)) among the cached metadata."""
+    name = ref_parts[-1] if ref_parts else ""
+    if not name:
+        return None
+    if len(ref_parts) >= 2:
+        ns = await _find_namespace(meta, ref_parts[-2])
+    else:
+        current = await meta.current_namespace()
+        ns = await _find_namespace(meta, current)
+    if ns is None:
+        return None
+    return next((t for t in await meta.tables(ns) if _same(t.name, name)), None)
+
+
+async def _columns_of(meta: MetaCache, parts: tuple[str, ...], dialect: str) -> list[Candidate]:
+    table = await _resolve(meta, parts)
+    if table is None:
+        return []
+    return [
+        Candidate(
+            quote_ident(c.name, dialect), "column", c.type_name + (" · pk" if c.primary_key else "")
+        )
+        for c in await meta.columns(table)
+    ]
+
+
+def _table_candidates(tables: list[Table], dialect: str) -> list[Candidate]:
+    return [
+        Candidate(quote_ident(t.name, dialect), "view" if t.is_view else "table") for t in tables
+    ]
+
+
+def _match(word: str, prefix: str) -> bool:
+    return word.lower().startswith(prefix.lower())
+
+
+def _keyword_case(word: str, prefix: str) -> str:
+    return word.lower() if prefix and prefix.islower() else word
+
+
+async def candidates(ctx: Context, meta: MetaCache | None, dialect: str) -> list[Candidate]:
+    """Ranked candidates for `ctx`. A metadata failure degrades to keywords only."""
+    found: list[Candidate] = []
+    if meta is not None:
+        try:
+            found = await _from_metadata(ctx, meta, dialect)
+        except DbError:
+            found = []
+    if ctx.kind != "qualified":
+        found += [Candidate(_keyword_case(k, ctx.prefix), "keyword") for k in keywords(dialect)]
+        if ctx.kind == "column":
+            found += [
+                Candidate(_keyword_case(f, ctx.prefix), "function") for f in functions(dialect)
+            ]
+    seen: set[tuple[str, str]] = set()
+    out: list[Candidate] = []
+    for c in found:
+        key = (c.text.lower(), c.kind)
+        if key in seen or not _match(c.text.strip('"`[]'), ctx.prefix):
+            continue
+        seen.add(key)
+        out.append(c)
+        if len(out) >= MAX_CANDIDATES:
+            break
+    return out
+
+
+async def _from_metadata(ctx: Context, meta: MetaCache, dialect: str) -> list[Candidate]:
+    if ctx.kind == "qualified":
+        return await _qualified(ctx, meta, dialect)
+    spaces = await meta.namespaces()
+    out: list[Candidate] = []
+    if ctx.kind == "table":
+        current = await meta.current_namespace()
+        ns = await _find_namespace(meta, current)
+        if ns is not None:
+            out += _table_candidates(await meta.tables(ns), dialect)
+        out += [Candidate(quote_ident(n.name, dialect), "schema") for n in spaces]
+        return out
+    # column context: columns of every table the statement mentions, then table names
+    for ref in ctx.tables:
+        out += await _columns_of(meta, ref.parts, dialect)
+    return out
+
+
+async def _qualified(ctx: Context, meta: MetaCache, dialect: str) -> list[Candidate]:
+    q = ctx.qualifier
+    ref = next((t for t in ctx.tables if t.alias and _same(t.alias, q[-1])), None)
+    if ref is not None:
+        return await _columns_of(meta, ref.parts, dialect)
+    if len(q) == 1:
+        ns = await _find_namespace(meta, q[0])
+        if ns is not None:
+            return _table_candidates(await meta.tables(ns), dialect)
+    # table-name qualifier: `users.` or `schema.users.`
+    return await _columns_of(meta, q, dialect)

sqlide/db/factory.py

@@ -0,0 +1,37 @@
+"""Glue: saved Connection + driver registry -> DbSession (not yet opened)."""
+
+from __future__ import annotations
+
+from sqlide.config.connections import Connection
+from sqlide.db.session import DbSession
+from sqlide.drivers.loader import load_driver
+from sqlide.drivers.registry import DriverRegistry
+
+
+def create_session(
+    conn: Connection, password: str | None, registry: DriverRegistry | None = None
+) -> DbSession:
+    """Blocking (may start the JVM, ~1s): call from a worker thread in the UI."""
+    registry = registry or DriverRegistry()
+    defn = registry.get(conn.driver)
+    loaded = load_driver(defn, registry.jar_paths(conn.driver))
+    return DbSession(
+        loaded,
+        conn.url,
+        conn.user,
+        password,
+        conn.properties,
+        defn.dialect,
+        conn.autocommit,
+    )
+
+
+_PRIVATE_MARKERS = (":mem:", ":memory:", "mode=memory", "jdbc:derby:memory", "jdbc:duckdb:")
+
+
+def is_private_database(url: str) -> bool:
+    """True when a second connection would not see this connection's data (in-memory DBs)."""
+    low = url.lower()
+    if low.startswith("jdbc:duckdb:"):
+        return low in ("jdbc:duckdb:", "jdbc:duckdb::memory:") or ":memory:" in low
+    return any(m in low for m in _PRIVATE_MARKERS)

sqlide/db/metadata.py

@@ -0,0 +1,174 @@
+"""Lazy, cached database metadata (schemas, tables, columns) read through JDBC DatabaseMetaData.
+
+Pure data + one class that needs a session; nothing here knows about the UI.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass
+from typing import Any
+
+import jpype
+
+from sqlide.db.session import DbSession, _db_error
+
+TABLE_TYPES = ["TABLE", "VIEW", "MATERIALIZED VIEW", "SYSTEM TABLE", "FOREIGN TABLE"]
+
+
+_SYSTEM = {
+    "information_schema", "pg_catalog", "pg_toast", "sys", "mysql", "performance_schema",
+    "system", "sysibm", "sysibmadm", "syscat", "sysstat", "ctxsys", "xdb", "mdsys",
+    "outln", "dbsnmp", "appqossys", "audsys", "gsmadmin_internal", "lbacsys", "ordsys",
+    "wmsys", "dvsys", "olapsys", "ojvmsys", "remote_scheduler_agent", "guest",
+}  # fmt: skip
+
+
+def is_system_namespace(name: str) -> bool:
+    low = name.lower()
+    return low in _SYSTEM or low.startswith(("pg_temp", "pg_toast"))
+
+
+@dataclass(frozen=True)
+class Namespace:
+    """A schema, or a catalog on databases that have no schemas (MySQL, ClickHouse)."""
+
+    name: str
+    is_catalog: bool = False
+
+
+@dataclass(frozen=True)
+class Table:
+    namespace: str
+    name: str
+    kind: str  # driver-specific: TABLE, BASE TABLE, VIEW, ...
+    is_catalog: bool = False
+
+    @property
+    def is_view(self) -> bool:
+        return "VIEW" in self.kind.upper()
+
+    @property
+    def qualified(self) -> str:
+        return f"{self.namespace}.{self.name}" if self.namespace else self.name
+
+
+@dataclass(frozen=True)
+class Column:
+    name: str
+    type_name: str
+    nullable: bool
+    primary_key: bool = False
+
+
+def _scope(name: str, is_catalog: bool) -> tuple[str | None, str | None]:
+    """(catalog, schema) arguments for DatabaseMetaData; "" means no filter at all."""
+    if not name:
+        return None, None
+    return (name, None) if is_catalog else (None, name)
+
+
+def _rows(rs: Any, *cols: str) -> list[tuple[Any, ...]]:
+    out = []
+    try:
+        while rs.next():
+            out.append(tuple(None if (v := rs.getString(c)) is None else str(v) for c in cols))
+    finally:
+        with contextlib.suppress(jpype.JException):
+            rs.close()
+    return out
+
+
+class MetaCache:
+    """Per-session cache. Every getter loads once; `refresh()` drops it."""
+
+    def __init__(self, session: DbSession) -> None:
+        self._s = session
+        self._namespaces: list[Namespace] | None = None
+        self._current: str | None = None
+        self._tables: dict[str, list[Table]] = {}
+        self._columns: dict[tuple[str, str], list[Column]] = {}
+
+    def use(self, session: DbSession) -> None:
+        """Read from another session (a dedicated one) from now on; the cache stays."""
+        self._s = session
+
+    def refresh(self) -> None:
+        self._namespaces = None
+        self._current = None
+        self._tables.clear()
+        self._columns.clear()
+
+    # --- loading ---
+    async def namespaces(self) -> list[Namespace]:
+        if self._namespaces is None:
+            self._namespaces = await self._s.call(self._load_namespaces)
+        return self._namespaces
+
+    @staticmethod
+    def _load_namespaces(conn: Any) -> list[Namespace]:
+        try:
+            md = conn.getMetaData()
+            schemas = [r[0] for r in _rows(md.getSchemas(), "TABLE_SCHEM")]
+            if schemas:
+                return [Namespace(s) for s in sorted(schemas, key=str.lower)]
+            cats = [r[0] for r in _rows(md.getCatalogs(), "TABLE_CAT")]
+            if cats:
+                return [Namespace(c, True) for c in sorted(cats, key=str.lower)]
+            return [Namespace("")]  # SQLite & co: no schemas at all, tables are just there
+        except jpype.JException as e:
+            raise _db_error(e) from e
+
+    async def current_namespace(self) -> str:
+        """The schema (or catalog) unqualified names resolve to; "" when unknown."""
+        if self._current is None:
+            self._current = await self._s.call(self._load_current)
+        return self._current
+
+    @staticmethod
+    def _load_current(conn: Any) -> str:
+        for getter in (conn.getSchema, conn.getCatalog):
+            try:
+                value = getter()
+            except jpype.JException:
+                continue
+            if value is not None:
+                return str(value)
+        return ""
+
+    async def tables(self, ns: Namespace) -> list[Table]:
+        if ns.name not in self._tables:
+            self._tables[ns.name] = await self._s.call(lambda c: self._load_tables(c, ns))
+        return self._tables[ns.name]
+
+    @staticmethod
+    def _load_tables(conn: Any, ns: Namespace) -> list[Table]:
+        try:
+            md = conn.getMetaData()
+            cat, sch = (ns.name, None) if ns.is_catalog else (None, ns.name)
+            types: Any = jpype.JArray(jpype.JString)
+            rs = md.getTables(cat, sch, "%", types(TABLE_TYPES))
+            rows = _rows(rs, "TABLE_NAME", "TABLE_TYPE")
+        except jpype.JException as e:
+            raise _db_error(e) from e
+        rows.sort(key=lambda r: (r[0] or "").lower())
+        return [Table(ns.name, n or "", t or "TABLE", ns.is_catalog) for n, t in rows]
+
+    async def columns(self, table: Table) -> list[Column]:
+        key = (table.namespace, table.name)
+        if key not in self._columns:
+            self._columns[key] = await self._s.call(lambda c: self._load_columns(c, table))
+        return self._columns[key]
+
+    @staticmethod
+    def _load_columns(conn: Any, t: Table) -> list[Column]:
+        try:
+            md = conn.getMetaData()
+            cat, sch = _scope(t.namespace, t.is_catalog)
+            pks = {r[0] for r in _rows(md.getPrimaryKeys(cat, sch, t.name), "COLUMN_NAME")}
+            rows = _rows(
+                md.getColumns(cat, sch, t.name, "%"), "COLUMN_NAME", "TYPE_NAME", "IS_NULLABLE"
+            )
+        except jpype.JException as e:
+            raise _db_error(e) from e
+        return [Column(n or "", ty or "", nl != "NO", n in pks) for n, ty, nl in rows]

sqlide/db/result.py

@@ -0,0 +1,52 @@
+"""Plain result containers. No JVM or UI imports."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+
+class DbError(Exception):
+    def __init__(self, message: str, sql_state: str = "", vendor_code: int = 0) -> None:
+        super().__init__(message)
+        self.sql_state = sql_state
+        self.vendor_code = vendor_code
+
+
+@dataclass(frozen=True, slots=True)
+class Column:
+    name: str
+    type_name: str
+    jdbc_type: int
+
+
+class RowSource(Protocol):
+    """Open server-side cursor: load further pages of the same result."""
+
+    async def fetch_more(self, n: int) -> tuple[list[tuple[Any, ...]], bool]:
+        """Return (rows, done)."""
+        ...
+
+    async def close(self) -> None: ...
+
+
+@dataclass(slots=True)
+class ResultItem:
+    """One result of a statement: either rows or an update count."""
+
+    columns: list[Column] = field(default_factory=list)
+    rows: list[tuple[Any, ...]] = field(default_factory=list)
+    update_count: int | None = None
+    cursor: RowSource | None = None  # set while more rows are pending
+
+    @property
+    def has_rows(self) -> bool:
+        return self.update_count is None
+
+
+@dataclass(slots=True)
+class Execution:
+    sql: str
+    items: list[ResultItem]
+    warnings: list[str]
+    elapsed_s: float