mycli 2.13.0__tar.gz → 2.13.2__tar.gz

{mycli-2.13.0/mycli.egg-info → mycli-2.13.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mycli
-Version: 2.13.0
-Summary: Rich terminal client for MySQL with autocompletion, syntax highlighting, and dataframes
+Version: 2.13.2
+Summary: Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes
 Author: Mycli Core Team
 License-Expression: BSD-3-Clause
 Project-URL: Homepage, https://mycli.net
@@ -51,6 +51,7 @@ Provides-Extra: llm
 Requires-Dist: llm~=0.31.1; extra == "llm"
 Requires-Dist: setuptools==83.*; extra == "llm"
 Requires-Dist: pip~=26.1.2; extra == "llm"
+Requires-Dist: openai~=2.48.0; extra == "llm"
 Provides-Extra: dataframe
 Requires-Dist: polars~=1.42.1; extra == "dataframe"
 Requires-Dist: altair~=6.2.2; extra == "dataframe"

{mycli-2.13.0 → mycli-2.13.2}/changelog.md

@@ -1,3 +1,30 @@
+2.13.2 (2026/08/12)
+==============
+
+Bugfixes
+---------
+* Avoid an exception when exiting while completions are being refreshed.
+* Avoid a completions exception when changing to a nonexistent database.
+
+
+Documentation
+---------
+* Shorten/clarify `pyproject.toml` project description.
+
+
+Internal
+---------
+* Fix CI by pinning the `openai` library to v2.48.0.
+
+
+2.13.1 (2026/08/11)
+==============
+
+Bugfixes
+---------
+* Pause before connecting over Boundary tunnels, to avoid SSL errors.
+
+
 2.13.0 (2026/08/11)
 ==============
 

{mycli-2.13.0 → mycli-2.13.2}/mycli/boundary_tunnel.py

@@ -15,6 +15,8 @@ from typing import IO
 
 from mycli.compat import WIN
 
+TUNNEL_STABILIZATION_PAUSE = 0.25
+
 
 class BoundaryTunnelError(RuntimeError):
     pass
@@ -146,6 +148,9 @@ class BoundaryTunnel:
             self._raise_if_failed()
             if self._is_listening():
                 self._ready.set()
+                # todo: if this works to ward off SSL errors at connection time,
+                # try making the pause as small as possible
+                time.sleep(TUNNEL_STABILIZATION_PAUSE)
                 return
             time.sleep(0.05)
         self.close()

{mycli-2.13.0 → mycli-2.13.2}/mycli/client.py

@@ -241,6 +241,10 @@ class MyCli(AppStateMixin, OutputMixin, ClientCommandsMixin, ClientConnectionMix
             self.prompt_session.app.invalidate()
 
     def close(self) -> None:
+        try:
+            self.completion_refresher.stop()
+        except Exception:
+            pass
         try:
             self.schema_prefetcher.stop()
         except Exception:

{mycli-2.13.0 → mycli-2.13.2}/mycli/client_query.py

@@ -40,6 +40,7 @@ class ClientQueryMixin:
 
         assert self.sqlexecute is not None
         if reset:
+            self.completion_refresher.stop()
             # Update the active completer's current-schema pointer right
             # away so unqualified completions reflect a schema switch
             # even before the background refresh finishes.

{mycli-2.13.0 → mycli-2.13.2}/mycli/completion_refresher.py

@@ -3,6 +3,7 @@ from time import monotonic
 from typing import Callable
 
 import pymysql
+from pymysql.constants.ER import BAD_DB_ERROR
 
 from mycli.packages.special.main import COMMANDS
 from mycli.packages.sqlresult import SQLResult
@@ -18,6 +19,9 @@ class CompletionRefresher:
     def __init__(self, invalidate_app: Callable[[], None] | None = None) -> None:
         self._completer_thread: threading.Thread | None = None
         self._restart_refresh = threading.Event()
+        self._stop_refresh = threading.Event()
+        self._executor_lock = threading.Lock()
+        self._active_executor: SQLExecute | None = None
         self._refresh_visible_until = 0.0
         self._visibility_timer: threading.Timer | None = None
         self._invalidate_app = invalidate_app
@@ -49,6 +53,7 @@ class CompletionRefresher:
             if self._visibility_timer is not None:
                 self._visibility_timer.cancel()
                 self._visibility_timer = None
+            self._stop_refresh.clear()
             self._refresh_visible_until = monotonic() + MIN_COMPLETION_REFRESH_MESSAGE_SECONDS
             self._completer_thread = threading.Thread(
                 target=self._bg_refresh, args=(executor, callbacks, completer_options), name="completion_refresh"
@@ -63,6 +68,29 @@ class CompletionRefresher:
     def _thread_is_alive(self) -> bool:
         return bool(self._completer_thread and self._completer_thread.is_alive())
 
+    def stop(self) -> None:
+        """Stop and wait for an in-flight completion refresh."""
+        self._stop_refresh.set()
+        self._restart_refresh.clear()
+        self._refresh_visible_until = 0.0
+        if self._visibility_timer is not None:
+            self._visibility_timer.cancel()
+            self._visibility_timer = None
+
+        with self._executor_lock:
+            executor = self._active_executor
+        if executor is not None:
+            try:
+                executor.close()
+            except Exception:
+                pass
+
+        thread = self._completer_thread
+        if thread is not None and thread.is_alive() and thread is not threading.current_thread():
+            thread.join()
+        if thread is not None and not thread.is_alive():
+            self._completer_thread = None
+
     def _bg_refresh(
         self,
         sqlexecute: SQLExecute,
@@ -89,7 +117,12 @@ class CompletionRefresher:
             self._finish_refreshing()
             return
 
+        with self._executor_lock:
+            self._active_executor = executor
         try:
+            if self._stop_refresh.is_set():
+                return
+
             # If callbacks is a single function then push it into a list.
             if callable(callbacks):
                 callbacks = [callbacks]
@@ -97,6 +130,8 @@ class CompletionRefresher:
             while 1:
                 for refresher in self.refreshers.values():
                     refresher(completer, executor)
+                    if self._stop_refresh.is_set():
+                        return
                     if self._restart_refresh.is_set():
                         self._restart_refresh.clear()
                         break
@@ -109,11 +144,26 @@ class CompletionRefresher:
                 # break statement.
                 continue
 
-            for callback in callbacks:
-                callback(completer)
+            if not self._stop_refresh.is_set():
+                for callback in callbacks:
+                    callback(completer)
+        except pymysql.err.OperationalError as error:
+            if not self._stop_refresh.is_set() and error.args[0] != BAD_DB_ERROR:
+                raise
+        except Exception:
+            if not self._stop_refresh.is_set():
+                raise
         finally:
-            executor.close()
-            self._finish_refreshing()
+            with self._executor_lock:
+                if self._active_executor is executor:
+                    self._active_executor = None
+            try:
+                executor.close()
+            except Exception:
+                if not self._stop_refresh.is_set():
+                    raise
+            finally:
+                self._finish_refreshing()
 
     def _finish_refreshing(self) -> None:
         self._invalidate()

{mycli-2.13.0 → mycli-2.13.2}/mycli/main_modes/repl.py

@@ -742,6 +742,10 @@ def _one_iteration(
             mycli.echo('Wise choice!')
             return
 
+    dropping_active_database = is_dropping_database(text, sqlexecute.dbname)
+    if dropping_active_database:
+        mycli.completion_refresher.stop()
+
     successful = False
     try:
         mycli.logger.debug('sql: %r', text)
@@ -870,13 +874,15 @@ def _one_iteration(
                     fg='yellow',
                 )
 
-        if is_dropping_database(text, sqlexecute.dbname):
+        if dropping_active_database:
             sqlexecute.dbname = None
             sqlexecute.connect()
 
         if need_completion_refresh(text):
-            mycli.refresh_completions(reset=need_completion_reset(text))
+            mycli.refresh_completions(reset=dropping_active_database or need_completion_reset(text))
     finally:
+        if dropping_active_database and not successful:
+            mycli.refresh_completions()
         if mycli.logfile is False:
             mycli.echo('Warning: This query was not logged.', err=True, fg='red')
 

{mycli-2.13.0 → mycli-2.13.2/mycli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mycli
-Version: 2.13.0
-Summary: Rich terminal client for MySQL with autocompletion, syntax highlighting, and dataframes
+Version: 2.13.2
+Summary: Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes
 Author: Mycli Core Team
 License-Expression: BSD-3-Clause
 Project-URL: Homepage, https://mycli.net
@@ -51,6 +51,7 @@ Provides-Extra: llm
 Requires-Dist: llm~=0.31.1; extra == "llm"
 Requires-Dist: setuptools==83.*; extra == "llm"
 Requires-Dist: pip~=26.1.2; extra == "llm"
+Requires-Dist: openai~=2.48.0; extra == "llm"
 Provides-Extra: dataframe
 Requires-Dist: polars~=1.42.1; extra == "dataframe"
 Requires-Dist: altair~=6.2.2; extra == "dataframe"

{mycli-2.13.0 → mycli-2.13.2}/mycli.egg-info/requires.txt

@@ -42,3 +42,4 @@ ruff~=0.15.0
 llm~=0.31.1
 setuptools==83.*
 pip~=26.1.2
+openai~=2.48.0

mycli-2.13.2/mycli.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.13.2",
+  "distance": 0,
+  "node": "g8da77508588513a62fa7ec1811a17f0c6ae14e86",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-12"
+}

{mycli-2.13.0 → mycli-2.13.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mycli"
 dynamic = ["version"]
-description = "Rich terminal client for MySQL with autocompletion, syntax highlighting, and dataframes"
+description = "Rich MySQL terminal client with autocompletion, syntax highlighting, and dataframes"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "BSD-3-Clause"
@@ -67,6 +67,7 @@ llm = [
     "llm ~= 0.31.1",
     "setuptools == 83.*",                   # Required by llm commands to install models
     "pip ~= 26.1.2",
+    "openai ~= 2.48.0",                     # openai v3.0.0 broke CI and would need work to support
 ]
 dataframe = [
     "polars ~= 1.42.1",
@@ -100,7 +101,7 @@ include = ["mycli*"]
 
 [tool.uv]
 exclude-newer = '1 week'
-exclude-newer-package = { cli_helpers = false, openai = false, cryptography = false }
+exclude-newer-package = { cli_helpers = false,  cryptography = false }
 
 [tool.ruff]
 target-version = 'py310'

{mycli-2.13.0 → mycli-2.13.2}/test/pytests/test_boundary_tunnel.py

@@ -12,7 +12,11 @@ from typing import Any, cast
 import pytest
 
 from mycli import boundary_tunnel
-from mycli.boundary_tunnel import BoundaryTunnel, BoundaryTunnelError
+from mycli.boundary_tunnel import (
+    TUNNEL_STABILIZATION_PAUSE,
+    BoundaryTunnel,
+    BoundaryTunnelError,
+)
 
 CONNECTION_DETAILS = (
     '{"address":"127.0.0.1","credentials":[{"secret":{"decoded":{"username":"1234","password":"5678"}}}],'
@@ -478,6 +482,7 @@ def test_boundary_tunnel_start_reads_stdout_in_worker_thread(monkeypatch: pytest
     monkeypatch.setattr(tunnel, '_read_stdout', fake_read_stdout)
     checks = iter([False, True])
     monkeypatch.setattr(tunnel, '_is_listening', lambda: next(checks))
+    monkeypatch.setattr(boundary_tunnel.time, 'sleep', lambda _seconds: None)
 
     tunnel.start()
 
@@ -504,6 +509,7 @@ def test_boundary_tunnel_start_authenticates_before_starting_worker(monkeypatch:
     monkeypatch.setattr(tunnel, '_authenticate_if_needed', fake_authenticate)
     monkeypatch.setattr(tunnel, '_run', fake_run)
     monkeypatch.setattr(tunnel, '_is_listening', lambda: True)
+    monkeypatch.setattr(boundary_tunnel.time, 'sleep', lambda _seconds: None)
 
     tunnel.start()
 
@@ -526,7 +532,7 @@ def test_boundary_tunnel_start_waits_for_process_to_start(monkeypatch: pytest.Mo
 
     tunnel.start()
 
-    assert sleeps == [0.05]
+    assert sleeps == [0.05, TUNNEL_STABILIZATION_PAUSE]
 
 
 def test_boundary_tunnel_start_reports_cli_status_code(monkeypatch: pytest.MonkeyPatch) -> None:

{mycli-2.13.0 → mycli-2.13.2}/test/pytests/test_client.py

@@ -391,23 +391,18 @@ def test_init_reads_mylogin_cnf(monkeypatch: pytest.MonkeyPatch, tmp_path: Path)
     assert cli.mylogin_cnf == {'client': 'config'}
 
 
-def test_close_stops_schema_prefetcher_and_closes_sqlexecute() -> None:
+def test_close_stops_refreshers_before_closing_connection_and_tunnels() -> None:
     cli = MyCli.__new__(MyCli)
-    stopped: list[bool] = []
-    closed: list[bool] = []
-    ssh_tunnel_closed: list[bool] = []
-    boundary_tunnel_closed: list[bool] = []
-    cli.schema_prefetcher = SimpleNamespace(stop=lambda: stopped.append(True))
-    cli.sqlexecute = SimpleNamespace(close=lambda: closed.append(True))  # type: ignore[assignment]
-    cast(Any, cli).ssh_tunnel = SimpleNamespace(close=lambda: ssh_tunnel_closed.append(True))
-    cli.boundary_tunnel = SimpleNamespace(close=lambda: boundary_tunnel_closed.append(True))  # type: ignore[assignment]
+    calls: list[str] = []
+    cli.completion_refresher = SimpleNamespace(stop=lambda: calls.append('completion'))
+    cli.schema_prefetcher = SimpleNamespace(stop=lambda: calls.append('prefetch'))
+    cli.sqlexecute = SimpleNamespace(close=lambda: calls.append('connection'))  # type: ignore[assignment]
+    cast(Any, cli).ssh_tunnel = SimpleNamespace(close=lambda: calls.append('ssh'))
+    cli.boundary_tunnel = SimpleNamespace(close=lambda: calls.append('boundary'))  # type: ignore[assignment]
 
     MyCli.close(cli)
 
-    assert stopped == [True]
-    assert closed == [True]
-    assert ssh_tunnel_closed == [True]
-    assert boundary_tunnel_closed == [True]
+    assert calls == ['completion', 'prefetch', 'connection', 'ssh', 'boundary']
 
 
 def test_close_swallows_cleanup_errors() -> None:
@@ -416,6 +411,7 @@ def test_close_swallows_cleanup_errors() -> None:
     def fail() -> None:
         raise RuntimeError('cleanup failed')
 
+    cli.completion_refresher = SimpleNamespace(stop=fail)
     cli.schema_prefetcher = SimpleNamespace(stop=fail)
     cli.sqlexecute = SimpleNamespace(close=fail)  # type: ignore[assignment]
     cast(Any, cli).ssh_tunnel = SimpleNamespace(close=fail)
@@ -425,6 +421,8 @@ def test_close_swallows_cleanup_errors() -> None:
 
 def test_close_swallows_boundary_tunnel_close_error() -> None:
     cli = MyCli.__new__(MyCli)
+    cli.completion_refresher = SimpleNamespace(stop=lambda: None)
+    cli.schema_prefetcher = SimpleNamespace(stop=lambda: None)
     cli.sqlexecute = None
     tunnel_closed: list[bool] = []
     cast(Any, cli).ssh_tunnel = SimpleNamespace(close=lambda: tunnel_closed.append(True))

{mycli-2.13.0 → mycli-2.13.2}/test/pytests/test_client_query.py

@@ -15,6 +15,7 @@ def make_refresh_cli() -> tuple[Any, dict[str, Any]]:
     cli = make_bare_mycli()
     state: dict[str, Any] = {
         'stopped': [],
+        'completion_stopped': [],
         'refresh_calls': [],
         'set_dbname_calls': [],
     }
@@ -30,7 +31,8 @@ def make_refresh_cli() -> tuple[Any, dict[str, Any]]:
     )
     cli.main_formatter = SimpleNamespace(supported_formats=['ascii', 'csv'])
     cli.completion_refresher = SimpleNamespace(
-        refresh=lambda executor, callbacks, options: state['refresh_calls'].append((executor, callbacks, options))
+        stop=lambda: state['completion_stopped'].append(True),
+        refresh=lambda executor, callbacks, options: state['refresh_calls'].append((executor, callbacks, options)),
     )
     cli.smart_completion = True
     state['callback'] = callback
@@ -79,6 +81,15 @@ def test_refresh_completions_does_not_update_dbname_without_reset() -> None:
     main.MyCli.refresh_completions(cli)
 
     assert state['set_dbname_calls'] == []
+    assert state['completion_stopped'] == []
+
+
+def test_refresh_completions_stops_completion_worker_when_reset() -> None:
+    cli, state = make_refresh_cli()
+
+    main.MyCli.refresh_completions(cli, reset=True)
+
+    assert state['completion_stopped'] == [True]
 
 
 def test_refresh_completions_updates_dbname_when_reset() -> None:
@@ -93,7 +104,7 @@ def test_refresh_completions_updates_dbname_when_reset() -> None:
         set_dbname=lambda dbname: set_dbname_calls.append(dbname),
     )
     cli.main_formatter = SimpleNamespace(supported_formats=['table'])
-    cli.completion_refresher = SimpleNamespace(refresh=lambda executor, callbacks, options: None)
+    cli.completion_refresher = SimpleNamespace(stop=lambda: None, refresh=lambda executor, callbacks, options: None)
 
     main.MyCli.refresh_completions(cli, reset=True)
 
@@ -113,7 +124,7 @@ def test_refresh_completions_uses_lock_when_reset() -> None:
         set_dbname=lambda dbname: None,
     )
     cli.main_formatter = SimpleNamespace(supported_formats=['table'])
-    cli.completion_refresher = SimpleNamespace(refresh=lambda executor, callbacks, options: None)
+    cli.completion_refresher = SimpleNamespace(stop=lambda: None, refresh=lambda executor, callbacks, options: None)
 
     main.MyCli.refresh_completions(cli, reset=True)
 

{mycli-2.13.0 → mycli-2.13.2}/test/pytests/test_completion_refresher.py

@@ -256,6 +256,108 @@ def test_refresh_cancels_pending_visibility_timer(monkeypatch, refresher) -> Non
     assert refresher._visibility_timer is None
 
 
+def test_stop_interrupts_and_joins_active_refresh(monkeypatch, refresher) -> None:
+    refresh_started = completion_refresher.threading.Event()
+    executor_closed = completion_refresher.threading.Event()
+    callback = Mock()
+    timer = Mock()
+
+    class FakeCompleter:
+        def __init__(self, **options) -> None:
+            pass
+
+    class FakeExecutor:
+        def __init__(self, *args) -> None:
+            pass
+
+        def close(self) -> None:
+            executor_closed.set()
+
+    def blocking_refresh(completer, executor) -> None:
+        refresh_started.set()
+        assert executor_closed.wait(timeout=1)
+        raise completion_refresher.pymysql.err.OperationalError(2013, 'connection closed')
+
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', FakeCompleter)
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', FakeExecutor)
+    refresher.refreshers = {'blocking': blocking_refresh}
+
+    refresher.refresh(make_sqlexecute(), callback)
+    assert refresh_started.wait(timeout=1)
+    refresher._visibility_timer = timer
+
+    refresher.stop()
+
+    assert executor_closed.is_set()
+    assert refresher._completer_thread is None
+    assert refresher._active_executor is None
+    assert refresher._restart_refresh.is_set() is False
+    assert refresher.is_refreshing() is False
+    timer.cancel.assert_called_once_with()
+    callback.assert_not_called()
+
+
+def test_stop_before_executor_is_ready_prevents_refresh_and_callback(monkeypatch, refresher) -> None:
+    constructor_started = completion_refresher.threading.Event()
+    release_constructor = completion_refresher.threading.Event()
+    stop_finished = completion_refresher.threading.Event()
+    refresh = Mock()
+    callback = Mock()
+
+    class FakeCompleter:
+        def __init__(self, **options) -> None:
+            pass
+
+    class FakeExecutor:
+        def __init__(self, *args) -> None:
+            constructor_started.set()
+            assert release_constructor.wait(timeout=1)
+
+        def close(self) -> None:
+            pass
+
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', FakeCompleter)
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', FakeExecutor)
+    refresher.refreshers = {'refresh': refresh}
+
+    refresher.refresh(make_sqlexecute(), callback)
+    assert constructor_started.wait(timeout=1)
+    stop_thread = completion_refresher.threading.Thread(target=lambda: (refresher.stop(), stop_finished.set()))
+    stop_thread.start()
+    assert refresher._stop_refresh.wait(timeout=1)
+    assert stop_finished.is_set() is False
+    release_constructor.set()
+    stop_thread.join(timeout=1)
+
+    assert stop_finished.is_set()
+    refresh.assert_not_called()
+    callback.assert_not_called()
+    assert refresher._completer_thread is None
+
+
+def test_stop_tolerates_executor_close_error_without_worker(refresher) -> None:
+    executor = Mock()
+    executor.close.side_effect = RuntimeError('close failed')
+    refresher._active_executor = executor
+
+    refresher.stop()
+
+    executor.close.assert_called_once_with()
+    assert refresher._completer_thread is None
+
+
+def test_stop_does_not_join_current_worker(monkeypatch, refresher) -> None:
+    thread = Mock()
+    thread.is_alive.return_value = True
+    refresher._completer_thread = thread
+    monkeypatch.setattr(completion_refresher.threading, 'current_thread', lambda: thread)
+
+    refresher.stop()
+
+    thread.join.assert_not_called()
+    assert refresher._completer_thread is thread
+
+
 def test_finish_refreshing_schedules_delayed_invalidation_before_deadline(monkeypatch, refresher) -> None:
     now = 10.0
     monkeypatch.setattr(completion_refresher, 'monotonic', lambda: now)
@@ -474,6 +576,110 @@ def test_bg_refresh_returns_when_executor_connection_fails(monkeypatch, refreshe
     callback.assert_not_called()
 
 
+def test_bg_refresh_stops_after_current_refresher(monkeypatch, refresher) -> None:
+    callback = Mock()
+    executor = Mock()
+
+    def stop_refresh(completer, active_executor) -> None:
+        refresher._stop_refresh.set()
+
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', Mock())
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', Mock(return_value=executor))
+    refresher.refreshers = {'stop': stop_refresh}
+
+    refresher._bg_refresh(make_sqlexecute(), callback, {})
+
+    callback.assert_not_called()
+    executor.close.assert_called_once_with()
+
+
+def test_bg_refresh_suppresses_non_operational_error_during_stop(monkeypatch, refresher) -> None:
+    executor = Mock()
+
+    def stop_with_error(completer, active_executor) -> None:
+        refresher._stop_refresh.set()
+        raise RuntimeError('cancelled refresh')
+
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', Mock())
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', Mock(return_value=executor))
+    refresher.refreshers = {'stop': stop_with_error}
+
+    refresher._bg_refresh(make_sqlexecute(), Mock(), {})
+
+    executor.close.assert_called_once_with()
+
+
+def test_bg_refresh_skips_callbacks_when_stopped_after_refresh(monkeypatch, refresher) -> None:
+    callback = Mock()
+    executor = Mock()
+    is_stopped = Mock(side_effect=[False, True])
+    monkeypatch.setattr(refresher._stop_refresh, 'is_set', is_stopped)
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', Mock())
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', Mock(return_value=executor))
+    refresher.refreshers = {}
+
+    refresher._bg_refresh(make_sqlexecute(), callback, {})
+
+    callback.assert_not_called()
+    assert is_stopped.call_count == 2
+
+
+def test_bg_refresh_propagates_unexpected_refresher_error(monkeypatch, refresher) -> None:
+    executor = Mock()
+
+    def fail_refresh(completer, active_executor) -> None:
+        refresher._active_executor = None
+        raise RuntimeError('refresh failed')
+
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', Mock())
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', Mock(return_value=executor))
+    refresher.refreshers = {'fail': fail_refresh}
+
+    with pytest.raises(RuntimeError, match='refresh failed'):
+        refresher._bg_refresh(make_sqlexecute(), Mock(), {})
+
+    executor.close.assert_called_once_with()
+
+
+@pytest.mark.parametrize('error_code', [completion_refresher.BAD_DB_ERROR, 2003])
+def test_bg_refresh_only_suppresses_stale_database_error(monkeypatch, refresher, error_code) -> None:
+    executor = Mock()
+    callback = Mock()
+
+    def fail_refresh(completer, active_executor) -> None:
+        raise completion_refresher.pymysql.err.OperationalError(error_code, 'metadata failed')
+
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', Mock())
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', Mock(return_value=executor))
+    refresher.refreshers = {'fail': fail_refresh}
+
+    if error_code == completion_refresher.BAD_DB_ERROR:
+        refresher._bg_refresh(make_sqlexecute(), callback, {})
+    else:
+        with pytest.raises(completion_refresher.pymysql.err.OperationalError, match='metadata failed'):
+            refresher._bg_refresh(make_sqlexecute(), callback, {})
+
+    callback.assert_not_called()
+    executor.close.assert_called_once_with()
+
+
+@pytest.mark.parametrize('stopping', [False, True])
+def test_bg_refresh_only_suppresses_executor_close_error_when_stopping(monkeypatch, refresher, stopping) -> None:
+    executor = Mock()
+    executor.close.side_effect = RuntimeError('close failed')
+    monkeypatch.setattr(completion_refresher, 'SQLCompleter', Mock())
+    monkeypatch.setattr(completion_refresher, 'SQLExecute', Mock(return_value=executor))
+    refresher.refreshers = {}
+    if stopping:
+        refresher._stop_refresh.set()
+
+    if stopping:
+        refresher._bg_refresh(make_sqlexecute(), Mock(), {})
+    else:
+        with pytest.raises(RuntimeError, match='close failed'):
+            refresher._bg_refresh(make_sqlexecute(), Mock(), {})
+
+
 def test_refresher_decorator_registers_function() -> None:
     refreshers: dict[str, object] = {}