begin pyodbc to mssql-python swap (#35)

* begin pyodbc to mssql-python swap

* correct non-optional dep blunder

* Remove ODBC driver selection infrastructure

- Delete sqlit/drivers.py (ODBC driver detection)
- Delete sqlit/ui/screens/driver_setup.py (ODBC driver setup screen)
- Remove DriverSetupScreen exports from sqlit/ui/__init__.py
- Remove DriverSetupScreen exports from sqlit/ui/screens/__init__.py

mssql-python doesn't require external ODBC drivers, so this
infrastructure is no longer needed.

* Remove MissingODBCDriverError and handler

- Remove MissingODBCDriverError class from sqlit/db/exceptions.py
- Remove MissingOdbcDriverHandler from connection_error_handlers.py

ODBC driver errors are no longer possible with mssql-python.

* Remove ODBC driver field from MSSQL schema

- Remove driver field from MSSQL_SCHEMA in sqlit/db/schema.py
- Remove SUPPORTED_DRIVERS import
- Remove _get_default_driver function from sqlit/config.py

mssql-python handles connections directly without driver selection.

* Remove Advanced tab from connection screen

- Remove Advanced TabPane from connection dialog
- Remove _split_groups_by_advanced method
- Remove _set_advanced_tab_enabled method
- Remove _show_advanced property
- Remove all tab-advanced references from navigation and validation
- Simplify field rendering (no longer splits general/advanced)

The Advanced tab only contained the ODBC driver selector which
is no longer needed with mssql-python.

* Clean up MSSQL adapter for mssql-python

- Remove driver selection logic from normalize_config
- Update docstring for driver_setup_kind property
- Update comment about sql_variant columns

* Update Arch Linux package mapping for mssql-python

Replace pyodbc -> python-pyodbc with mssql-python -> python-mssql
in the Arch Linux package name mapping.

* Update docs: pyodbc -> mssql-python

- Update driver reference table in README.md
- Remove note about ODBC driver requirement
- Remove pyodbc mypy override from pyproject.toml

* Remove ODBC driver integration tests

Delete tests/integration/drivers/ directory containing:
- ODBC driver installation tests
- ODBC driver UI flow tests
- Docker test infrastructure for driver testing
- Test artifacts and screenshots

These tests are obsolete with mssql-python which doesn't require
ODBC driver installation.

* Update tests for mssql-python migration

- Update test_mssql_datetimeoffset.py docstrings
- Remove driver field from test fixtures in test_credentials_service.py
- Remove pyodbc reference from test_database_base.py
- Remove Advanced tab tests from test_connection_screen.py

* Update CI to use mssql-python instead of pyodbc

- Remove ODBC driver installation step (no longer needed)
- Change pip install pyodbc to pip install mssql-python

---------

Co-authored-by: Peter Adams <18162810+Maxteabag@users.noreply.github.com>

Author: dzsquared

.github/workflows/ci.yml

@@ -120,18 +120,11 @@ jobs:
         with:
           python-version: "3.12"
 
-      - name: Install ODBC driver
-        run: |
-          curl https://packages.microsoft.com/keys/microsoft.asc | sudo tee /etc/apt/trusted.gpg.d/microsoft.asc
-          curl https://packages.microsoft.com/config/ubuntu/22.04/prod.list | sudo tee /etc/apt/sources.list.d/mssql-release.list
-          sudo apt-get update
-          sudo ACCEPT_EULA=Y apt-get install -y msodbcsql18 unixodbc-dev
-
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           pip install -e ".[test]"
-          pip install pyodbc
+          pip install mssql-python
 
       - name: Wait for SQL Server to be ready
         run: |

README.md

@@ -239,7 +239,7 @@ Most of the time you can just run `sqlit` and connect. If a Python driver is mis
 | :---------------------------------- | :--------------------------- | :------------------------------------------------- | :------------------------------------------------- |
 | SQLite                              | *(built-in)*                 | *(built-in)*                                       | *(built-in)*                                       |
 | PostgreSQL / CockroachDB / Supabase | `psycopg2-binary`            | `pipx inject sqlit-tui psycopg2-binary`            | `python -m pip install psycopg2-binary`            |
-| SQL Server                          | `pyodbc`                     | `pipx inject sqlit-tui pyodbc`                     | `python -m pip install pyodbc`                     |
+| SQL Server                          | `mssql-python`               | `pipx inject sqlit-tui mssql-python`               | `python -m pip install mssql-python`               |
 | MySQL                               | `mysql-connector-python`     | `pipx inject sqlit-tui mysql-connector-python`     | `python -m pip install mysql-connector-python`     |
 | MariaDB                             | `mariadb`                    | `pipx inject sqlit-tui mariadb`                    | `python -m pip install mariadb`                    |
 | Oracle                              | `oracledb`                   | `pipx inject sqlit-tui oracledb`                   | `python -m pip install oracledb`                   |
@@ -250,8 +250,6 @@ Most of the time you can just run `sqlit` and connect. If a Python driver is mis
 | Snowflake                           | `snowflake-connector-python` | `pipx inject sqlit-tui snowflake-connector-python` | `python -m pip install snowflake-connector-python` |
 | Firebird                            | `firebirdsql`                | `pipx inject sqlit-tui firebirdsql`                | `python -m pip install firebirdsql`                |
 
-**Note:** SQL Server also requires the platform-specific ODBC driver. On your first connection attempt, `sqlit` can help you install it if it's missing.
-
 ### SSH Tunnel Support
 
 SSH tunnel functionality requires additional dependencies. Install with the `ssh` extra:

pyproject.toml

@@ -30,14 +30,14 @@ dependencies = [
     "textual-fastdatatable>=0.14.0",
     "pyperclip>=1.8.2",
     "keyring>=24.0.0",
-    "docker>=7.0.0",  # Docker container auto-detection (lazy loaded)
+    "docker>=7.0.0",
 ]
 dynamic = ["version"]
 
 [project.optional-dependencies]
 all = [
     "psycopg2-binary>=2.9.0",
-    "pyodbc>=5.0.0",
+    "mssql-python>=1.1.0",
     "mysql-connector-python>=9.1.0",  # min avoids known CVEs
     "mariadb>=1.1.0",
     "oracledb>=2.0.0",
@@ -52,7 +52,7 @@ all = [
 ]
 postgres = ["psycopg2-binary>=2.9.0"]
 cockroachdb = ["psycopg2-binary>=2.9.0"]
-mssql = ["pyodbc>=5.0.0"]
+mssql = ["mssql-python>=1.1.0"]
 mysql = ["mysql-connector-python>=9.1.0"]  # min avoids known CVEs
 mariadb = ["mariadb>=1.1.0"]
 oracle = ["oracledb>=2.0.0"]
@@ -169,5 +169,5 @@ module = [
 ignore_missing_imports = true
 
 [[tool.mypy.overrides]]
-module = "pyodbc"
+module = "mssql_python"
 ignore_missing_imports = true

sqlit/config.py

@@ -144,12 +144,6 @@ class AuthType(Enum):
 }
 
 
-def _get_default_driver() -> str:
-    """Get default ODBC driver (lazy import)."""
-    from .drivers import SUPPORTED_DRIVERS
-    return SUPPORTED_DRIVERS[0]
-
-
 @dataclass
 class ConnectionConfig:
     """Database connection configuration."""

sqlit/db/adapters/base.py

@@ -239,7 +239,7 @@ def execute_test_query(self, conn: Any) -> None:
 
     @property
     def driver_setup_kind(self) -> str | None:
-        """Optional driver setup type for UI workflows (e.g., 'odbc')."""
+        """Optional driver setup type for UI workflows."""
         return None
 
     def normalize_config(self, config: ConnectionConfig) -> ConnectionConfig:

sqlit/db/adapters/mssql.py

@@ -1,4 +1,4 @@
-"""Microsoft SQL Server adapter using pyodbc."""
+"""Microsoft SQL Server adapter using mssql-python."""
 
 from __future__ import annotations
 
@@ -10,24 +10,8 @@
     from ...config import ConnectionConfig
 
 
-def _convert_datetimeoffset(value: bytes) -> str:
-    """Convert SQL Server datetimeoffset binary to ISO 8601 string.
-
-    The binary format is 20 bytes: year(2), month(2), day(2), hour(2),
-    minute(2), second(2), nanoseconds(4), tz_hour(2), tz_minute(2).
-    See: https://github.com/mkleehammer/pyodbc/issues/134
-    """
-    import struct
-
-    tup = struct.unpack("<6hI2h", value)
-    year, month, day, hour, minute, second, ns, tz_hour, tz_min = tup
-    microseconds = ns // 1000
-    tz_sign = "+" if tz_hour >= 0 else "-"
-    return f"{year:04d}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d}.{microseconds:06d} {tz_sign}{abs(tz_hour):02d}:{abs(tz_min):02d}"
-
-
 class SQLServerAdapter(DatabaseAdapter):
-    """Adapter for Microsoft SQL Server using pyodbc."""
+    """Adapter for Microsoft SQL Server using the mssql-python driver."""
 
     @classmethod
     def badge_label(cls) -> str:
@@ -47,11 +31,13 @@ def install_extra(self) -> str:
 
     @property
     def install_package(self) -> str:
-        return "pyodbc"
+        # Package providing the SQL Server driver (no external ODBC manager required)
+        return "mssql-python"
 
     @property
     def driver_import_names(self) -> tuple[str, ...]:
-        return ("pyodbc",)
+        # DB-API 2.0 compatible driver
+        return ("mssql_python",)
 
     @property
     def supports_multiple_databases(self) -> bool:
@@ -89,7 +75,9 @@ def supports_sequences(self) -> bool:
 
     @property
     def driver_setup_kind(self) -> str | None:
-        return "odbc"
+        # mssql-python uses Direct Database Connectivity and does not require
+        # a separate ODBC driver manager.
+        return None
 
     @classmethod
     def docker_image_patterns(cls) -> tuple[str, ...]:
@@ -123,36 +111,24 @@ def normalize_config(self, config: ConnectionConfig) -> ConnectionConfig:
             config.set_option("auth_type", "sql")
             config.set_option("trusted_connection", False)
 
-        driver = config.get_option("driver")
-        if not driver:
-            from ...config import _get_default_driver
-
-            config.set_option("driver", _get_default_driver())
-
         return config
 
     def _build_connection_string(self, config: ConnectionConfig) -> str:
-        """Build ODBC connection string from config.
+        """Build mssql-python connection string from config.
 
         Args:
             config: Connection configuration.
 
         Returns:
-            ODBC connection string for pyodbc.
+            semicolon-delimited key=value connection string.
         """
         from ...config import AuthType
 
         server_with_port = config.server
         if config.port and config.port != "1433":
             server_with_port = f"{config.server},{config.port}"
 
-        driver = config.get_option("driver")
-        if not driver:
-            from ...config import _get_default_driver
-
-            driver = _get_default_driver()
         base = (
-            f"DRIVER={{{driver}}};"
             f"SERVER={server_with_port};"
             f"DATABASE={config.database or 'master'};"
             f"TrustServerCertificate=yes;"
@@ -163,7 +139,7 @@ def _build_connection_string(self, config: ConnectionConfig) -> str:
         if auth == AuthType.WINDOWS:
             return base + "Trusted_Connection=yes;"
         elif auth == AuthType.SQL_SERVER:
-            return base + f"UID={config.username};PWD={config.password};"
+            return base + f"Authentication=SqlPassword;" f"UID={config.username};PWD={config.password};"
         elif auth == AuthType.AD_PASSWORD:
             return base + f"Authentication=ActiveDirectoryPassword;" f"UID={config.username};PWD={config.password};"
         elif auth == AuthType.AD_INTERACTIVE:
@@ -174,30 +150,16 @@ def _build_connection_string(self, config: ConnectionConfig) -> str:
         return base + "Trusted_Connection=yes;"
 
     def connect(self, config: ConnectionConfig) -> Any:
-        """Connect to SQL Server using pyodbc."""
-        pyodbc = import_driver_module(
-            "pyodbc",
+        """Connect to SQL Server using the mssql-python driver."""
+        mssql_python = import_driver_module(
+            "mssql_python",
             driver_name=self.name,
             extra_name=self.install_extra,
             package_name=self.install_package,
         )
 
-        installed = list(pyodbc.drivers())
-        driver = config.get_option("driver")
-        if not driver:
-            from ...config import _get_default_driver
-
-            driver = _get_default_driver()
-        if driver not in installed:
-            from ...db.exceptions import MissingODBCDriverError
-
-            raise MissingODBCDriverError(driver, installed)
-
         conn_str = self._build_connection_string(config)
-        conn = pyodbc.connect(conn_str, timeout=10)
-
-        # Register converter for datetimeoffset (ODBC type -155) which pyodbc doesn't support natively
-        conn.add_output_converter(-155, _convert_datetimeoffset)
+        conn = mssql_python.connect(conn_str)
 
         return conn
 
@@ -451,7 +413,7 @@ def get_sequence_definition(
     ) -> dict[str, Any]:
         """Get detailed information about a SQL Server sequence."""
         cursor = conn.cursor()
-        # Cast sql_variant columns to BIGINT to avoid pyodbc type -25 error
+        # Cast sql_variant columns to BIGINT to avoid driver type conversion errors
         if database:
             cursor.execute(
                 f"SELECT CAST(start_value AS BIGINT), CAST(increment AS BIGINT), "

sqlit/db/exceptions.py

@@ -19,12 +19,3 @@ def __init__(
         self.module_name = module_name
         self.import_error = import_error
         super().__init__(f"Missing driver for {driver_name}")
-
-
-class MissingODBCDriverError(ConnectionError):
-    """Exception raised when a required ODBC driver is not installed (SQL Server)."""
-
-    def __init__(self, selected_driver: str, installed_drivers: list[str]):
-        self.selected_driver = selected_driver
-        self.installed_drivers = installed_drivers
-        super().__init__(f"Missing ODBC driver: {selected_driver}")

sqlit/db/schema.py

@@ -10,8 +10,6 @@
 from dataclasses import dataclass
 from enum import Enum
 
-from ..drivers import SUPPORTED_DRIVERS
-
 
 class FieldType(Enum):
     TEXT = "text"
@@ -201,10 +199,6 @@ def _get_ssh_fields() -> tuple[SchemaField, ...]:
 SSH_FIELDS = _get_ssh_fields()
 
 
-def _get_mssql_driver_options() -> tuple[SelectOption, ...]:
-    return tuple(SelectOption(d, d) for d in SUPPORTED_DRIVERS)
-
-
 def _get_mssql_auth_options() -> tuple[SelectOption, ...]:
     return (
         SelectOption("sql", "SQL Server Authentication"),
@@ -234,14 +228,6 @@ def _get_mssql_auth_options() -> tuple[SelectOption, ...]:
         ),
         _port_field("1433"),
         _database_field(),
-        SchemaField(
-            name="driver",
-            label="Driver",
-            field_type=FieldType.SELECT,
-            options=_get_mssql_driver_options(),
-            default=SUPPORTED_DRIVERS[0],
-            advanced=True,
-        ),
         SchemaField(
             name="auth_type",
             label="Authentication",