From 9a5edbd0ee8a860b38f70366f958b6522b1a6ccf Mon Sep 17 00:00:00 2001 From: Artur Badenes Puig Date: Fri, 13 Nov 2026 09:58:46 +0100 Subject: [PATCH] fix(autocomplete): skip server-wide schema indexing on servers with many databases With no database selected, autocomplete indexed every user database on the server. On a SQL Server instance with hundreds of databases that queued hundreds of metadata queries on the single connection executor and processed millions of entries on the UI thread, leaving the app unresponsive for minutes. Past MAX_SERVER_WIDE_INDEX_DATABASES (20) databases, indexing is skipped with a warning; selecting a database indexes just that one, as before. Co-Authored-By: Claude Opus 5.5 --- .../query/ui/mixins/autocomplete_schema.py | 22 ++++++ .../unit/test_autocomplete_many_databases.py | 70 +++++++++++++++++++ 2 files changed, 92 insertions(+) create mode 100644 tests/unit/test_autocomplete_many_databases.py diff --git a/sqlit/domains/query/ui/mixins/autocomplete_schema.py b/sqlit/domains/query/ui/mixins/autocomplete_schema.py index 3c481769..6c326cc5 100644 --- a/sqlit/domains/query/ui/mixins/autocomplete_schema.py +++ b/sqlit/domains/query/ui/mixins/autocomplete_schema.py @@ -11,6 +11,20 @@ SCHEMA_PROCESS_BATCH_SIZE = 200 +# With no database selected, autocomplete indexes every user database on the +# server. Past this many databases that means hundreds of metadata queries +# queued on the single connection executor (blocking the explorer and user +# queries for minutes) and millions of entries processed on the UI thread, so +# indexing waits until the user picks a database. +MAX_SERVER_WIDE_INDEX_DATABASES = 20 + + +def _too_many_databases_message(count: int) -> str: + return ( + f"Autocomplete not indexed: the server has {count} databases. " + "Select a database in the explorer (Enter on it) to index it." + ) + def _dedupe_routines(routines: list[Any]) -> list[Any]: """Deduplicate routines without collapsing equal names in other schemas.""" @@ -346,6 +360,11 @@ def _on_databases_loaded(self: AutocompleteMixinHost, databases: list) -> None: return caps = provider.capabilities + if len(databases) > MAX_SERVER_WIDE_INDEX_DATABASES: + self._stop_schema_spinner() + self.notify(_too_many_databases_message(len(databases)), severity="warning") + return + self._schema_pending_dbs = databases self._schema_total_jobs = len(databases) * 3 # tables, views, procedures per db supports_procedures = caps.supports_stored_procedures and isinstance(provider.schema_inspector, ProcedureInspector) @@ -821,6 +840,9 @@ async def run_db_call(fn: Any, *args: Any, **kwargs: Any) -> Any: all_dbs = await run_db_call(inspector.get_databases, connection) system_dbs = {s.lower() for s in caps.system_databases} databases = [d for d in all_dbs if d.lower() not in system_dbs] + if len(databases) > MAX_SERVER_WIDE_INDEX_DATABASES: + self.notify(_too_many_databases_message(len(databases)), severity="warning") + return else: databases = [] else: diff --git a/tests/unit/test_autocomplete_many_databases.py b/tests/unit/test_autocomplete_many_databases.py new file mode 100644 index 00000000..975cbd96 --- /dev/null +++ b/tests/unit/test_autocomplete_many_databases.py @@ -0,0 +1,70 @@ +"""Server-wide autocomplete indexing is skipped on servers with many databases.""" + +from __future__ import annotations + +from types import SimpleNamespace +from typing import Any + +from sqlit.domains.query.ui.mixins.autocomplete_schema import ( + MAX_SERVER_WIDE_INDEX_DATABASES, + AutocompleteSchemaMixin, +) + + +class _Host(AutocompleteSchemaMixin): + def __init__(self) -> None: + self.current_provider = SimpleNamespace( + capabilities=SimpleNamespace(supports_stored_procedures=False), + schema_inspector=object(), + ) + self.current_connection = object() + self.notifications: list[tuple[str, str]] = [] + self.loaded: list[tuple[str, Any]] = [] + self.spinner_stopped = False + + def notify(self, message: str, severity: str = "information") -> None: + self.notifications.append((message, severity)) + + def _stop_schema_spinner(self) -> None: + self.spinner_stopped = True + + def _load_tables_job(self, database: Any) -> None: + self.loaded.append(("tables", database)) + + def _load_views_job(self, database: Any) -> None: + self.loaded.append(("views", database)) + + def _schema_job_complete(self) -> None: + pass + + +def test_many_databases_skip_indexing_and_warn() -> None: + host = _Host() + databases = [f"db{i}" for i in range(MAX_SERVER_WIDE_INDEX_DATABASES + 1)] + + host._on_databases_loaded(databases) + + assert host.loaded == [] + assert host.spinner_stopped + assert len(host.notifications) == 1 + message, severity = host.notifications[0] + assert severity == "warning" + assert str(len(databases)) in message + + +def test_few_databases_are_indexed() -> None: + host = _Host() + databases = [f"db{i}" for i in range(MAX_SERVER_WIDE_INDEX_DATABASES)] + + host._on_databases_loaded(databases) + + assert ("tables", "db0") in host.loaded + assert host.notifications == [] + + +def test_selected_database_is_always_indexed() -> None: + host = _Host() + + host._on_databases_loaded(["AppDb"]) + + assert host.loaded == [("tables", "AppDb"), ("views", "AppDb")]