Synced from main

Author: scottnemes

README.md

@@ -105,8 +105,22 @@ sudo dnf install mycli
 
 ### Windows
 
+#### Option 1: Native Windows
+
+Install the `less` pager, for example by `scoop install less`.
+
 Follow the instructions on this blogpost: http://web.archive.org/web/20221006045208/https://www.codewall.co.uk/installing-using-mycli-on-windows/
 
+**Mycli is not tested on Windows**, but the libraries used in the app are Windows-compatible.
+This means it should work without any modifications, but isn't supported.
+
+PRs to add native Windows testing to Mycli CI would be welcome!
+
+#### Option 2: WSL
+
+Everything should work as expected in WSL.  This is a good option for using
+Mycli on Windows.
+
 
 ### Thanks:
 
@@ -128,9 +142,6 @@ Thanks to [PyMysql](https://github.com/PyMySQL/PyMySQL) for a pure python adapte
 
 Mycli is tested on macOS and Linux, and requires Python 3.10 or better.
 
-**Mycli is not tested on Windows**, but the libraries used in this app are Windows-compatible.
-This means it should work without any modifications. If you're unable to run it
-on Windows, please [file a bug](https://github.com/dbcli/mycli/issues/new).
 
 ### Configuration and Usage
 

changelog.md

@@ -5,13 +5,22 @@ Features
 --------
 * Update query processing functions to allow automatic show_warnings to work for more code paths like DDL.
 * Update the default SSL value to connect securely by default. Add a --no-ssl option to disable it.
+* Rework reconnect logic to actually reconnect or create a new connection instead of simply changing the database (#746).
+
 
 Bug Fixes
 --------
 * Update the prompt display logic to handle an edge case where a socket is used without
   a host being parsed from any other method (#707).
 
 
+Internal
+--------
+* Refine documentation for Windows.
+* Target Python 3.10 for linting.
+* Use fully-qualified pymysql exception classes.
+
+
 1.42.0 (2025/12/20)
 ==============
 

mycli/main.py

@@ -37,8 +37,8 @@
 from prompt_toolkit.layout.processors import ConditionalProcessor, HighlightMatchingBracketProcessor
 from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.shortcuts import CompleteStyle, PromptSession
-from pymysql import OperationalError, err
-from pymysql.constants.ER import HANDSHAKE_ERROR
+import pymysql
+from pymysql.constants.ER import ERROR_CODE_ACCESS_DENIED, HANDSHAKE_ERROR
 from pymysql.cursors import Cursor
 import sqlglot
 import sqlparse
@@ -214,7 +214,7 @@ def close(self) -> None:
     def register_special_commands(self) -> None:
         special.register_special_command(self.change_db, "use", "\\u", "Change to a new database.", aliases=["\\u"])
         special.register_special_command(
-            self.change_db,
+            self.manual_reconnect,
             "connect",
             "\\r",
             "Reconnect to the database. Optional database argument.",
@@ -261,6 +261,18 @@ def register_special_commands(self) -> None:
             self.change_prompt_format, "prompt", "\\R", "Change prompt format.", aliases=["\\R"], case_sensitive=True
         )
 
+    def manual_reconnect(self, arg: str = "", **_) -> Generator[tuple, None, None]:
+        """
+        Interactive method to use for the \r command, so that the utility method
+        may be cleanly used elsewhere.
+        """
+        if not self.reconnect(database=arg):
+            yield (None, None, None, "Not connected")
+        elif not arg or arg == '``':
+            yield (None, None, None, None)
+        else:
+            yield self.change_db(arg).send(None)
+
     def enable_show_warnings(self, **_) -> Generator[tuple, None, None]:
         self.show_warnings = True
         msg = "Show warnings enabled."
@@ -301,13 +313,18 @@ def change_db(self, arg: str, **_) -> Generator[tuple, None, None]:
             return
 
         assert isinstance(self.sqlexecute, SQLExecute)
-        self.sqlexecute.change_db(arg)
+
+        if self.sqlexecute.dbname == arg:
+            msg = f'You are already connected to database "{self.sqlexecute.dbname}" as user "{self.sqlexecute.user}"'
+        else:
+            self.sqlexecute.change_db(arg)
+            msg = f'You are now connected to database "{self.sqlexecute.dbname}" as user "{self.sqlexecute.user}"'
 
         yield (
             None,
             None,
             None,
-            f'You are now connected to database "{self.sqlexecute.dbname}" as user "{self.sqlexecute.user}"',
+            msg,
         )
 
     def execute_from_file(self, arg: str, **_) -> Iterable[tuple]:
@@ -526,7 +543,7 @@ def _connect() -> None:
             }
             try:
                 self.sqlexecute = SQLExecute(**conn_config)
-            except OperationalError as e:
+            except pymysql.OperationalError as e:
                 if e.args[0] == ERROR_CODE_ACCESS_DENIED:
                     if password_from_file is not None:
                         conn_config["password"] = password_from_file
@@ -547,7 +564,7 @@ def _connect() -> None:
                 self.echo(f"Connecting to socket {socket}, owned by user {socket_owner}", err=True)
                 try:
                     _connect()
-                except OperationalError as e:
+                except pymysql.OperationalError as e:
                     # These are "Can't open socket" and 2x "Can't connect"
                     if [code for code in (2001, 2002, 2003) if code == e.args[0]]:
                         self.logger.debug("Database connection failed: %r.", e)
@@ -900,19 +917,12 @@ def one_iteration(text: str | None = None) -> None:
                 output_res(res, start)
                 special.unset_once_if_written(self.post_redirect_command)
                 special.flush_pipe_once_if_written(self.post_redirect_command)
-            except err.InterfaceError:
-                logger.debug("Attempting to reconnect.")
-                self.echo("Reconnecting...", fg="yellow")
-                try:
-                    sqlexecute.connect()
-                    logger.debug("Reconnected successfully.")
-                    one_iteration(text)
-                    return  # OK to just return, cuz the recursion call runs to the end.
-                except OperationalError as e2:
-                    logger.debug("Reconnect failed. e: %r", e2)
-                    self.echo(str(e2), err=True, fg="red")
-                    # If reconnection failed, don't proceed further.
+            except pymysql.err.InterfaceError:
+                # attempt to reconnect
+                if not self.reconnect():
                     return
+                one_iteration(text)
+                return  # OK to just return, cuz the recursion call runs to the end.
             except EOFError as e:
                 raise e
             except KeyboardInterrupt:
@@ -943,21 +953,14 @@ def one_iteration(text: str | None = None) -> None:
                     self.echo("Did not get a connection id, skip cancelling query", err=True, fg="red")
             except NotImplementedError:
                 self.echo("Not Yet Implemented.", fg="yellow")
-            except OperationalError as e1:
+            except pymysql.OperationalError as e1:
                 logger.debug("Exception: %r", e1)
                 if e1.args[0] in (2003, 2006, 2013):
-                    logger.debug("Attempting to reconnect.")
-                    self.echo("Reconnecting...", fg="yellow")
-                    try:
-                        sqlexecute.connect()
-                        logger.debug("Reconnected successfully.")
-                        one_iteration(text)
-                        return  # OK to just return, cuz the recursion call runs to the end.
-                    except OperationalError as e2:
-                        logger.debug("Reconnect failed. e: %r", e2)
-                        self.echo(str(e2), err=True, fg="red")
-                        # If reconnection failed, don't proceed further.
+                    # attempt to reconnect
+                    if not self.reconnect():
                         return
+                    one_iteration(text)
+                    return  # OK to just return, cuz the recursion call runs to the end.
                 else:
                     logger.error("sql: %r, error: %r", text, e1)
                     logger.error("traceback: %r", traceback.format_exc())
@@ -1029,6 +1032,58 @@ def one_iteration(text: str | None = None) -> None:
             if not self.less_chatty:
                 self.echo("Goodbye!")
 
+    def reconnect(self, database: str = "") -> bool:
+        """
+        Attempt to reconnect to the server. Return True if successful,
+        False if unsuccessful.
+
+        The "database" argument is used only to improve messages.
+        """
+        assert self.sqlexecute is not None
+        assert self.sqlexecute.conn is not None
+
+        # First pass with ping(reconnect=False) and minimal feedback levels.  This definitely
+        # works as expected, and is a good idea especially when "connect" was used as a
+        # synonym for "use".
+        try:
+            self.sqlexecute.conn.ping(reconnect=False)
+            if not database:
+                self.echo("Already connected.", fg="yellow")
+            return True
+        except pymysql.err.Error:
+            pass
+
+        # Second pass with ping(reconnect=True).  It is not demonstrated that this pass ever
+        # gives the benefit it is looking for, _ie_ preserves session state.  We need to test
+        # this with connection pooling.
+        try:
+            old_connection_id = self.sqlexecute.connection_id
+            self.logger.debug("Attempting to reconnect.")
+            self.echo("Reconnecting...", fg="yellow")
+            self.sqlexecute.conn.ping(reconnect=True)
+            self.logger.debug("Reconnected successfully.")
+            self.echo("Reconnected successfully.", fg="yellow")
+            self.sqlexecute.reset_connection_id()
+            if old_connection_id != self.sqlexecute.connection_id:
+                self.echo("Any session state was reset.", fg="red")
+            return True
+        except pymysql.err.Error:
+            pass
+
+        # Third pass with sqlexecute.connect() should always work, but always resets session state.
+        try:
+            self.logger.debug("Creating new connection")
+            self.echo("Creating new connection...", fg="yellow")
+            self.sqlexecute.connect()
+            self.logger.debug("New connection created successfully.")
+            self.echo("New connection created successfully.", fg="yellow")
+            self.echo("Any session state was reset.", fg="red")
+            return True
+        except pymysql.OperationalError as e:
+            self.logger.debug("Reconnect failed. e: %r", e)
+            self.echo(str(e), err=True, fg="red")
+            return False
+
     def log_output(self, output: str) -> None:
         """Log the output in the audit log, if it's enabled."""
         if isinstance(self.logfile, TextIOWrapper):

mycli/packages/special/llm.py

@@ -304,7 +304,7 @@ def sql_using_llm(
         row = cur.fetchone()
         if row is None:
             continue
-        sample_data[table_name] = list(zip(cols, row))
+        sample_data[table_name] = list(zip(cols, row, strict=True))
     args = [
         "--template",
         LLM_TEMPLATE_NAME,

pyproject.toml

@@ -55,7 +55,7 @@ dev = [
     "llm>=0.19.0",
     "setuptools",                   # Required by llm commands to install models
     "pip",
-    "ruff>=0.14.6",
+    "ruff~=0.14.10",
 ]
 
 [project.scripts]
@@ -68,7 +68,7 @@ mycli = ["myclirc", "AUTHORS", "SPONSORS"]
 include = ["mycli*"]
 
 [tool.ruff]
-target-version = 'py39'
+target-version = 'py310'
 line-length = 140
 
 [tool.ruff.lint]

test/features/fixture_data/help_commands.txt

@@ -19,6 +19,7 @@
 | help           | \?                         | Show this help.                                            |
 | nopager        | \n                         | Disable pager, print to stdout.                            |
 | notee          | notee                      | Stop writing results to an output file.                    |
+| nowarnings     | \w                         | Disable automatic warnings display.                        |
 | pager          | \P [command]               | Set PAGER. Print the query results via PAGER.              |
 | prompt         | \R                         | Change prompt format.                                      |
 | quit           | \q                         | Quit.                                                      |
@@ -30,5 +31,6 @@
 | tableformat    | \T                         | Change the table format used to output results.            |
 | tee            | tee [-o] filename          | Append all results to an output file (overwrite using -o). |
 | use            | \u                         | Change to a new database.                                  |
+| warnings       | \W                         | Enable automatic warnings display.                         |
 | watch          | watch [seconds] [-c] query | Executes the query every [seconds] seconds (by default 5). |
 +----------------+----------------------------+------------------------------------------------------------+

test/features/steps/crud_database.py

@@ -108,6 +108,6 @@ def step_see_db_dropped_no_default(context):
 @then("we see database connected")
 def step_see_db_connected(context):
     """Wait to see drop database output."""
-    wrappers.expect_exact(context, 'You are now connected to database "', timeout=2)
+    wrappers.expect_exact(context, 'connected to database "', timeout=2)
     wrappers.expect_exact(context, '"', timeout=2)
     wrappers.expect_exact(context, f' as user "{context.conf["user"]}"', timeout=2)

test/test_main.py

@@ -10,6 +10,7 @@
 from click.testing import CliRunner
 
 from mycli.main import MyCli, cli, thanks_picker
+import mycli.packages.special
 from mycli.packages.special.main import COMMANDS as SPECIAL_COMMANDS
 from mycli.sqlexecute import ServerInfo, SQLExecute
 from test.utils import HOST, PASSWORD, PORT, USER, dbtest, run
@@ -37,6 +38,95 @@
 ]
 
 
+@dbtest
+def test_reconnect_no_database(executor, capsys):
+    m = MyCli()
+    m.register_special_commands()
+    m.sqlexecute = SQLExecute(
+        None,
+        USER,
+        PASSWORD,
+        HOST,
+        PORT,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+    )
+    sql = "\\r"
+    result = next(mycli.packages.special.execute(executor, sql))
+    stdout, _stderr = capsys.readouterr()
+    assert result[-1] is None
+    assert "Already connected" in stdout
+
+
+@dbtest
+def test_reconnect_with_different_database(executor):
+    m = MyCli()
+    m.register_special_commands()
+    m.sqlexecute = SQLExecute(
+        None,
+        USER,
+        PASSWORD,
+        HOST,
+        PORT,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+    )
+    database_1 = "mycli_test_db"
+    database_2 = "mysql"
+    sql_1 = f"use {database_1}"
+    sql_2 = f"\\r {database_2}"
+    _result_1 = next(mycli.packages.special.execute(executor, sql_1))
+    result_2 = next(mycli.packages.special.execute(executor, sql_2))
+    expected = f'You are now connected to database "{database_2}" as user "{USER}"'
+    assert expected in result_2[-1]
+
+
+@dbtest
+def test_reconnect_with_same_database(executor):
+    m = MyCli()
+    m.register_special_commands()
+    m.sqlexecute = SQLExecute(
+        None,
+        USER,
+        PASSWORD,
+        HOST,
+        PORT,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+    )
+    database = "mysql"
+    sql = f"\\u {database}"
+    result = next(mycli.packages.special.execute(executor, sql))
+    sql = f"\\r {database}"
+    result = next(mycli.packages.special.execute(executor, sql))
+    expected = f'You are already connected to database "{database}" as user "{USER}"'
+    assert expected in result[-1]
+
+
 @dbtest
 def test_prompt_no_host_only_socket(executor):
     mycli = MyCli()