jusi-clickhouse 0.2.0__tar.gz

jusi_clickhouse-0.2.0/.gitignore

@@ -0,0 +1,24 @@
+# Python bytecode and caches
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+
+# Virtual environments
+.venv/
+venv/
+venv*/
+
+# Local runtime state
+.env
+.env.*
+.DS_Store

jusi_clickhouse-0.2.0/Dockerfile

@@ -0,0 +1,6 @@
+FROM clickhouse/clickhouse-server:25.4-alpine
+
+LABEL org.opencontainers.image.title="jusi-clickhouse-dev"
+LABEL org.opencontainers.image.description="Local ClickHouse fixture for jusi-clickhouse development"
+
+COPY docker/clickhouse/initdb.d/ /docker-entrypoint-initdb.d/

jusi_clickhouse-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 notawhaleble
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jusi_clickhouse-0.2.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: jusi-clickhouse
+Version: 0.2.0
+Summary: ClickHouse exact-provider plugin for Jusi 1.0 SQL
+Author: Jusi contributors
+License: MIT License
+        
+        Copyright (c) 2026 notawhaleble
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: clickhouse-connect>=0.7
+Requires-Dist: jusi-sql<0.3,>=0.2
+Requires-Dist: jusi<2,>=1.0
+Requires-Dist: visidata<4,>=3
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# jusi-clickhouse
+
+`jusi-clickhouse` is the ClickHouse exact-provider plugin for Jusi 1.0 and the
+shared `jusi-sql` family. It exposes the `clickhouse` provider for `%%sql`
+cells. The family owns target selection, magic dispatch, completion ranges,
+metadata caching, operation routing, and common VisiData SQL commands.
+
+Configure a SQL target in the Jusi session config:
+
+```toml
+[sql.targets.analytics]
+provider = "clickhouse"
+host = "localhost"
+port = 8123
+username = "default"
+password = ""
+database = "default"
+initial_fetch = 100
+```
+
+Use it from a cell:
+
+```sql
+%%sql analytics
+SELECT *
+FROM system.numbers
+LIMIT 1000
+```
+
+Results open in VisiData. Press `1`-`9` to fetch more rows, `gf` to prompt for a fetch count (`0` fetches the rest), and `gb` to open the selected raw value through VisiData. `gc` and `gr` are present for SQL-family parity, but ClickHouse transaction control is reported as unsupported.
+
+Follow-up cells reuse the same VisiData application, ClickHouse connection, and
+open result streams. `JusiInterrupt` requests cancellation of active queries.
+Closing the client closes its streams, connection, private control socket, and
+staged launch data.
+
+For a local manual-test database:
+
+```bash
+./scripts/run-clickhouse.sh
+```
+
+The script builds `jusi-clickhouse-dev`, starts a local ClickHouse container, loads demo tables under `demo`, waits until it is ready, and prints a matching `jusi.toml` block.

jusi_clickhouse-0.2.0/README.md

@@ -0,0 +1,43 @@
+# jusi-clickhouse
+
+`jusi-clickhouse` is the ClickHouse exact-provider plugin for Jusi 1.0 and the
+shared `jusi-sql` family. It exposes the `clickhouse` provider for `%%sql`
+cells. The family owns target selection, magic dispatch, completion ranges,
+metadata caching, operation routing, and common VisiData SQL commands.
+
+Configure a SQL target in the Jusi session config:
+
+```toml
+[sql.targets.analytics]
+provider = "clickhouse"
+host = "localhost"
+port = 8123
+username = "default"
+password = ""
+database = "default"
+initial_fetch = 100
+```
+
+Use it from a cell:
+
+```sql
+%%sql analytics
+SELECT *
+FROM system.numbers
+LIMIT 1000
+```
+
+Results open in VisiData. Press `1`-`9` to fetch more rows, `gf` to prompt for a fetch count (`0` fetches the rest), and `gb` to open the selected raw value through VisiData. `gc` and `gr` are present for SQL-family parity, but ClickHouse transaction control is reported as unsupported.
+
+Follow-up cells reuse the same VisiData application, ClickHouse connection, and
+open result streams. `JusiInterrupt` requests cancellation of active queries.
+Closing the client closes its streams, connection, private control socket, and
+staged launch data.
+
+For a local manual-test database:
+
+```bash
+./scripts/run-clickhouse.sh
+```
+
+The script builds `jusi-clickhouse-dev`, starts a local ClickHouse container, loads demo tables under `demo`, waits until it is ready, and prints a matching `jusi.toml` block.

jusi_clickhouse-0.2.0/docker/clickhouse/initdb.d/001_jusi_demo.sql

@@ -0,0 +1,74 @@
+CREATE DATABASE IF NOT EXISTS demo;
+
+CREATE TABLE IF NOT EXISTS demo.accounts
+(
+    id UInt64,
+    email String,
+    display_name String,
+    active Bool,
+    created_at DateTime
+)
+ENGINE = MergeTree
+ORDER BY id;
+
+CREATE TABLE IF NOT EXISTS demo.events
+(
+    id UInt64,
+    account_id UInt64,
+    event_type LowCardinality(String),
+    payload String,
+    created_at DateTime
+)
+ENGINE = MergeTree
+ORDER BY (account_id, id);
+
+CREATE TABLE IF NOT EXISTS demo.blob_files
+(
+    id UInt64,
+    filename String,
+    content_type String,
+    payload String,
+    created_at DateTime
+)
+ENGINE = MergeTree
+ORDER BY id;
+
+TRUNCATE TABLE demo.accounts;
+TRUNCATE TABLE demo.events;
+TRUNCATE TABLE demo.blob_files;
+
+INSERT INTO demo.accounts (id, email, display_name, active, created_at) VALUES
+    (1, 'ada@example.test', 'Ada Lovelace', true, now() - INTERVAL 3 DAY),
+    (2, 'grace@example.test', 'Grace Hopper', true, now() - INTERVAL 2 DAY),
+    (3, 'alan@example.test', 'Alan Turing', false, now() - INTERVAL 1 DAY);
+
+INSERT INTO demo.events (id, account_id, event_type, payload, created_at) VALUES
+    (1, 1, 'login', '{"ip":"127.0.0.1"}', now() - INTERVAL 3 HOUR),
+    (2, 1, 'query', '{"rows":42}', now() - INTERVAL 2 HOUR),
+    (3, 2, 'login', '{"ip":"127.0.0.2"}', now() - INTERVAL 1 HOUR),
+    (4, 3, 'disabled_login', '{"reason":"inactive"}', now());
+
+INSERT INTO demo.blob_files (id, filename, content_type, payload, created_at) VALUES
+    (
+        1,
+        'test-blob.zip',
+        'application/zip',
+        unhex('504b03040a0000000000231ab65c2909ab311b0000001b0000000f001c00626c6f622d726561646d652e747874555409000382a00f6a82a00f6a75780b000104f501000004140000004a75736920506f73746772657320626c6f6220666978747572650a504b01021e030a0000000000231ab65c2909ab311b0000001b0000000f0018000000000001000000a48100000000626c6f622d726561646d652e747874555405000382a00f6a75780b000104f50100000414000000504b0506000000000100010055000000640000000000'),
+        now()
+    );
+
+CREATE OR REPLACE VIEW demo.account_summary AS
+SELECT
+    a.id,
+    a.email,
+    a.display_name,
+    a.active,
+    count(e.id) AS event_count,
+    max(e.created_at) AS last_event_at
+FROM demo.accounts AS a
+LEFT JOIN demo.events AS e ON e.account_id = a.id
+GROUP BY
+    a.id,
+    a.email,
+    a.display_name,
+    a.active;

jusi_clickhouse-0.2.0/examples/jusi.toml

@@ -0,0 +1,8 @@
+[sql.targets.local_clickhouse]
+provider = "clickhouse"
+host = "127.0.0.1"
+port = 58123
+username = "jusi"
+password = "jusi"
+database = "demo"
+initial_fetch = 100

jusi_clickhouse-0.2.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "jusi-clickhouse"
+version = "0.2.0"
+description = "ClickHouse exact-provider plugin for Jusi 1.0 SQL"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE" }
+authors = [
+  { name = "Jusi contributors" }
+]
+dependencies = [
+  "clickhouse-connect>=0.7",
+  "jusi>=1.0,<2",
+  "jusi-sql>=0.2,<0.3",
+  "visidata>=3,<4",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8,<9"]
+
+[project.entry-points."jusi.plugins.v1"]
+clickhouse = "jusi_clickhouse.catalog:catalog_entry"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/jusi_clickhouse"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

jusi_clickhouse-0.2.0/scripts/run-clickhouse.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+IMAGE_NAME="${JUSI_CLICKHOUSE_IMAGE:-jusi-clickhouse-dev}"
+CONTAINER_NAME="${JUSI_CLICKHOUSE_CONTAINER:-jusi-clickhouse-dev}"
+HTTP_PORT="${JUSI_CLICKHOUSE_HTTP_PORT:-58123}"
+NATIVE_PORT="${JUSI_CLICKHOUSE_NATIVE_PORT:-59000}"
+CLICKHOUSE_USER="${JUSI_CLICKHOUSE_USER:-jusi}"
+CLICKHOUSE_PASSWORD="${JUSI_CLICKHOUSE_PASSWORD:-jusi}"
+CLICKHOUSE_DB="${JUSI_CLICKHOUSE_DB:-demo}"
+RECREATE="${JUSI_CLICKHOUSE_RECREATE:-0}"
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+docker build -t "${IMAGE_NAME}" "${ROOT_DIR}"
+
+if [[ "${RECREATE}" == "1" ]] && docker ps -a --format '{{.Names}}' | grep -Fxq "${CONTAINER_NAME}"; then
+  docker rm -f "${CONTAINER_NAME}" >/dev/null
+fi
+
+if docker ps --format '{{.Names}}' | grep -Fxq "${CONTAINER_NAME}"; then
+  echo "ClickHouse container '${CONTAINER_NAME}' is already running on HTTP port ${HTTP_PORT}."
+else
+  if docker ps -a --format '{{.Names}}' | grep -Fxq "${CONTAINER_NAME}"; then
+    docker rm "${CONTAINER_NAME}" >/dev/null
+  fi
+
+  docker run \
+    --detach \
+    --name "${CONTAINER_NAME}" \
+    --publish "127.0.0.1:${HTTP_PORT}:8123" \
+    --publish "127.0.0.1:${NATIVE_PORT}:9000" \
+    --env "CLICKHOUSE_USER=${CLICKHOUSE_USER}" \
+    --env "CLICKHOUSE_PASSWORD=${CLICKHOUSE_PASSWORD}" \
+    --env "CLICKHOUSE_DB=${CLICKHOUSE_DB}" \
+    "${IMAGE_NAME}" >/dev/null
+fi
+
+echo "Waiting for ClickHouse to accept connections..."
+for _ in $(seq 1 90); do
+  if docker exec "${CONTAINER_NAME}" clickhouse-client \
+    --user "${CLICKHOUSE_USER}" \
+    --password "${CLICKHOUSE_PASSWORD}" \
+    --database "${CLICKHOUSE_DB}" \
+    --query "SELECT 1" >/dev/null 2>&1; then
+    cat <<EOF
+ClickHouse is running.
+
+jusi.toml:
+
+[sql.targets.local_clickhouse]
+provider = "clickhouse"
+host = "127.0.0.1"
+port = ${HTTP_PORT}
+username = "${CLICKHOUSE_USER}"
+password = "${CLICKHOUSE_PASSWORD}"
+database = "${CLICKHOUSE_DB}"
+initial_fetch = 25
+
+Manual test queries:
+
+%%sql local_clickhouse
+SELECT * FROM demo.account_summary ORDER BY id
+
+%%sql local_clickhouse
+SELECT number FROM system.numbers LIMIT 50
+
+%%sql local_clickhouse
+SELECT filename, content_type, payload FROM demo.blob_files
+EOF
+    exit 0
+  fi
+  sleep 1
+done
+
+echo "ClickHouse did not become ready in time." >&2
+docker logs "${CONTAINER_NAME}" >&2 || true
+exit 1

jusi_clickhouse-0.2.0/src/jusi_clickhouse/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "0.2.0"

jusi_clickhouse-0.2.0/src/jusi_clickhouse/catalog.py

@@ -0,0 +1,19 @@
+"""Lightweight Jusi 1.0 catalog provider; imports no runtime dependencies."""
+from __future__ import annotations
+
+from typing import Any
+
+from jusi_sql import sql_catalog_entry
+
+from . import __version__
+
+
+def catalog_entry() -> dict[str, Any]:
+    return sql_catalog_entry(
+        plugin_id="clickhouse",
+        plugin_version=__version__,
+        distribution="jusi-clickhouse",
+        kernel_extension="jusi_clickhouse.kernel",
+        worker_entry_point="jusi_clickhouse.worker:create_worker",
+        provider_presentation={"syntax": "clickhouse", "indent": "sql"},
+    )

jusi_clickhouse-0.2.0/src/jusi_clickhouse/config.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+PLUGIN_OPTIONS = {"provider", "initial_fetch"}
+
+
+@dataclass(frozen=True)
+class ClickHouseOptions:
+    connect: dict[str, Any]
+    initial_fetch: int
+
+
+def parse_clickhouse_options(options: Mapping[str, Any]) -> ClickHouseOptions:
+    raw_initial = options.get("initial_fetch", 100)
+    try:
+        initial_fetch = int(raw_initial)
+    except (TypeError, ValueError):
+        initial_fetch = 100
+    if initial_fetch < 0:
+        initial_fetch = 0
+    connect = {str(key): value for key, value in options.items() if str(key) not in PLUGIN_OPTIONS}
+    return ClickHouseOptions(connect=connect, initial_fetch=initial_fetch)

jusi_clickhouse-0.2.0/src/jusi_clickhouse/constants.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+CLICKHOUSE_BOOTSTRAP_SQL = "SELECT 1 AS jusi_bootstrap WHERE 0"

jusi_clickhouse-0.2.0/src/jusi_clickhouse/ipc.py

@@ -0,0 +1,129 @@
+"""Private worker/application control channel for one ClickHouse client."""
+from __future__ import annotations
+
+import json
+import os
+import socket
+import threading
+from typing import Any, Callable
+from uuid import uuid4
+
+
+class WorkerApplicationBridge:
+    def __init__(self, socket_path: str) -> None:
+        self.socket_path = socket_path
+        self._listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self._listener.bind(socket_path)
+        self._listener.listen(1)
+        self._connection: socket.socket | None = None
+        self._connected = threading.Event()
+        self._closed = threading.Event()
+        self._write_lock = threading.Lock()
+        self._condition = threading.Condition()
+        self._responses: dict[str, dict[str, Any]] = {}
+        threading.Thread(target=self._accept, name="jusi-clickhouse-bridge", daemon=True).start()
+
+    def _accept(self) -> None:
+        try:
+            connection, _ = self._listener.accept()
+            self._connection = connection
+            self._connected.set()
+            with connection.makefile("r", encoding="utf-8") as stream:
+                for line in stream:
+                    response = json.loads(line)
+                    request_id = str(response.get("id", ""))
+                    if request_id:
+                        with self._condition:
+                            self._responses[request_id] = response
+                            self._condition.notify_all()
+        except (OSError, ValueError, json.JSONDecodeError):
+            pass
+        finally:
+            self._closed.set()
+            self._connected.set()
+            with self._condition:
+                self._condition.notify_all()
+
+    def request(self, operation: str, payload: dict[str, Any]) -> dict[str, Any]:
+        if not self._connected.wait(10) or self._connection is None:
+            raise RuntimeError("ClickHouse terminal application did not connect")
+        request_id = uuid4().hex
+        self._send({"id": request_id, "operation": operation, "payload": payload})
+        with self._condition:
+            while request_id not in self._responses and not self._closed.is_set():
+                self._condition.wait()
+            response = self._responses.pop(request_id, None)
+        if response is None:
+            raise RuntimeError("ClickHouse terminal application disconnected")
+        return response
+
+    def interrupt(self) -> None:
+        if self._connection is not None and not self._closed.is_set():
+            self._send({"id": uuid4().hex, "operation": "interrupt", "payload": {}})
+
+    def _send(self, message: dict[str, Any]) -> None:
+        connection = self._connection
+        if connection is None:
+            raise RuntimeError("ClickHouse terminal application is unavailable")
+        data = (json.dumps(message, ensure_ascii=False) + "\n").encode("utf-8")
+        with self._write_lock:
+            connection.sendall(data)
+
+    def close(self) -> None:
+        self._closed.set()
+        try:
+            self._listener.close()
+        except OSError:
+            pass
+        if self._connection is not None:
+            try:
+                self._connection.shutdown(socket.SHUT_RDWR)
+            except OSError:
+                pass
+            self._connection.close()
+        try:
+            os.unlink(self.socket_path)
+        except FileNotFoundError:
+            pass
+        with self._condition:
+            self._condition.notify_all()
+
+
+class ApplicationController:
+    def __init__(self, socket_path: str, handler: Callable[[str, dict[str, Any]], dict[str, Any]]) -> None:
+        self._handler = handler
+        self._connection = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self._connection.connect(socket_path)
+        self._write_lock = threading.Lock()
+
+    def start(self) -> None:
+        threading.Thread(target=self._read, name="jusi-clickhouse-control", daemon=True).start()
+
+    def _read(self) -> None:
+        try:
+            with self._connection.makefile("r", encoding="utf-8") as stream:
+                for line in stream:
+                    message = json.loads(line)
+                    operation = str(message.get("operation", ""))
+                    if operation == "interrupt":
+                        self._handle(message)
+                    else:
+                        threading.Thread(target=self._handle, args=(message,), daemon=True).start()
+        except (OSError, ValueError, json.JSONDecodeError):
+            return
+
+    def _handle(self, message: dict[str, Any]) -> None:
+        payload = message.get("payload", {})
+        if not isinstance(payload, dict):
+            payload = {}
+        try:
+            result = self._handler(str(message.get("operation", "")), payload)
+            response = {"ok": True, "result": result}
+        except BaseException as exc:
+            response = {"ok": False, "error": "fatal", "message": f"{type(exc).__name__}: {exc}"}
+        response = {"id": str(message.get("id", "")), **response}
+        try:
+            with self._write_lock:
+                self._connection.sendall((json.dumps(response, ensure_ascii=False) + "\n").encode("utf-8"))
+        except OSError:
+            return

jusi_clickhouse-0.2.0/src/jusi_clickhouse/kernel.py

@@ -0,0 +1,19 @@
+"""Thin exact-provider adapter for the shared Jusi SQL kernel dispatcher."""
+from __future__ import annotations
+
+from jusi_sql.kernel import SqlKernelAdapter
+
+from . import __version__
+from .constants import CLICKHOUSE_BOOTSTRAP_SQL
+
+
+_adapter = SqlKernelAdapter(
+    plugin_id="clickhouse",
+    plugin_version=__version__,
+    selectors=("clickhouse",),
+    empty_sql=CLICKHOUSE_BOOTSTRAP_SQL,
+)
+
+jusi_kernel_adapter_v1 = _adapter.manifest
+configure_jusi_runtime_v1 = _adapter.configure
+load_ipython_extension = _adapter.load

jusi_clickhouse-0.2.0/src/jusi_clickhouse/metadata.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Any
+
+from jusi_sql import CompletionColumn, CompletionObject, MetadataSnapshot
+
+
+def load_clickhouse_metadata(client: Any) -> MetadataSnapshot:
+    schemas = [str(row[0]) for row in _query_rows(client, "SELECT name FROM system.databases ORDER BY name")]
+    object_rows = _query_rows(
+        client,
+        """
+        SELECT database, name, engine
+        FROM system.tables
+        WHERE database NOT IN ('INFORMATION_SCHEMA', 'information_schema')
+        ORDER BY database, name
+        """,
+    )
+    objects = [
+        CompletionObject(schema=str(row[0]), name=str(row[1]), kind=_table_kind(str(row[2])), detail=str(row[2]))
+        for row in object_rows
+    ]
+    column_rows = _query_rows(
+        client,
+        """
+        SELECT database, table, name, type
+        FROM system.columns
+        WHERE database NOT IN ('INFORMATION_SCHEMA', 'information_schema')
+        ORDER BY database, table, position
+        """,
+    )
+    columns = [
+        CompletionColumn(schema=str(row[0]), table=str(row[1]), name=str(row[2]), data_type=str(row[3]))
+        for row in column_rows
+    ]
+    function_rows = _query_rows(client, "SELECT name, origin FROM system.functions ORDER BY name")
+    functions = [
+        CompletionObject(schema="", name=str(row[0]), kind="function", detail=str(row[1]))
+        for row in function_rows
+    ]
+    return MetadataSnapshot(schemas=schemas, objects=objects, columns=columns, functions=functions)
+
+
+def _query_rows(client: Any, sql: str) -> list[Any]:
+    result = client.query(sql)
+    return list(getattr(result, "result_rows", []) or [])
+
+
+def _table_kind(engine: str) -> str:
+    normalized = engine.lower()
+    if normalized == "view":
+        return "view"
+    if "dictionary" in normalized:
+        return "dictionary"
+    return "table"