Add time zone testing and handling for mssql

Author: Maxteabag

sqlit/db/adapters/mssql.py

@@ -10,6 +10,22 @@
     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."""
 
@@ -178,7 +194,12 @@ def connect(self, config: ConnectionConfig) -> Any:
             raise MissingODBCDriverError(driver, installed)
 
         conn_str = self._build_connection_string(config)
-        return pyodbc.connect(conn_str, timeout=10)
+        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)
+
+        return conn
 
     def get_databases(self, conn: Any) -> list[str]:
         """Get list of databases from SQL Server."""

tests/integration/test_mssql_datetimeoffset.py

@@ -0,0 +1,203 @@
+"""Integration tests for SQL Server datetimeoffset support.
+
+Tests the fix for pyodbc ODBC type -155 (datetimeoffset) which is not natively supported.
+See: https://github.com/mkleehammer/pyodbc/issues/134
+"""
+
+from __future__ import annotations
+
+import os
+import pytest
+
+
+MSSQL_HOST = os.environ.get("MSSQL_HOST", "localhost")
+MSSQL_PORT = int(os.environ.get("MSSQL_PORT", "1433"))
+MSSQL_USER = os.environ.get("MSSQL_USER", "sa")
+MSSQL_PASSWORD = os.environ.get("MSSQL_PASSWORD", "YourStrong@Passw0rd")
+MSSQL_DATABASE = os.environ.get("MSSQL_DATABASE", "master")
+
+
+@pytest.fixture
+def mssql_adapter():
+    """Get MSSQL adapter instance."""
+    from sqlit.db.adapters.mssql import SQLServerAdapter
+    return SQLServerAdapter()
+
+
+@pytest.fixture
+def mssql_config():
+    """Get MSSQL connection config."""
+    from sqlit.config import ConnectionConfig
+    return ConnectionConfig(
+        name="test-mssql-dto",
+        db_type="mssql",
+        server=MSSQL_HOST,
+        port=str(MSSQL_PORT),
+        database=MSSQL_DATABASE,
+        username=MSSQL_USER,
+        password=MSSQL_PASSWORD,
+        options={"auth_type": "sql"},
+    )
+
+
+def is_mssql_available() -> bool:
+    """Check if SQL Server is available."""
+    import socket
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(2)
+        result = sock.connect_ex((MSSQL_HOST, MSSQL_PORT))
+        sock.close()
+        return result == 0
+    except Exception:
+        return False
+
+
+@pytest.mark.integration
+@pytest.mark.mssql
+class TestMSSQLDatetimeOffset:
+    """Integration tests for datetimeoffset column support."""
+
+    @pytest.fixture(autouse=True)
+    def skip_if_unavailable(self):
+        """Skip tests if SQL Server is not available."""
+        if not is_mssql_available():
+            pytest.skip("SQL Server is not available")
+        try:
+            import pyodbc
+            drivers = [d for d in pyodbc.drivers() if "SQL Server" in d]
+            if not drivers:
+                pytest.skip("No SQL Server ODBC driver installed")
+        except ImportError:
+            pytest.skip("pyodbc is not installed")
+
+    def test_query_datetimeoffset_column(self, mssql_adapter, mssql_config):
+        """Test that querying a table with datetimeoffset columns works.
+
+        Previously this would fail with:
+        'ODBC SQL type -155 is not yet supported. column-index=N type=-155'
+        """
+        conn = mssql_adapter.connect(mssql_config)
+
+        try:
+            cursor = conn.cursor()
+
+            # Create table with datetimeoffset column
+            cursor.execute("""
+                IF OBJECT_ID('test_audit_log', 'U') IS NOT NULL
+                    DROP TABLE test_audit_log
+            """)
+            cursor.execute("""
+                CREATE TABLE test_audit_log (
+                    id INT PRIMARY KEY,
+                    action NVARCHAR(100),
+                    created_at DATETIMEOFFSET NOT NULL,
+                    modified_at DATETIMEOFFSET
+                )
+            """)
+
+            # Insert test data with various timezone offsets
+            cursor.execute("""
+                INSERT INTO test_audit_log (id, action, created_at, modified_at) VALUES
+                (1, 'INSERT', '2024-01-15 10:30:00.123456 -05:00', '2024-01-15 11:00:00.000000 -05:00'),
+                (2, 'UPDATE', '2024-06-20 14:45:30.500000 +00:00', '2024-06-20 15:00:00.000000 +00:00'),
+                (3, 'DELETE', '2024-12-01 08:15:45.999999 +05:30', NULL)
+            """)
+            conn.commit()
+
+            # Query the table - this would fail before the fix
+            columns, rows, truncated = mssql_adapter.execute_query(
+                conn, "SELECT * FROM test_audit_log ORDER BY id"
+            )
+
+            # Verify we got results
+            assert len(columns) == 4
+            assert len(rows) == 3
+
+            # Verify column names
+            assert columns == ["id", "action", "created_at", "modified_at"]
+
+            # Verify datetimeoffset values are returned as strings
+            # Row 1: Eastern time (-05:00)
+            assert rows[0][0] == 1
+            assert rows[0][1] == "INSERT"
+            assert "2024-01-15" in rows[0][2]
+            assert "10:30:00" in rows[0][2]
+            assert "-05:00" in rows[0][2]
+
+            # Row 2: UTC (+00:00)
+            assert rows[1][0] == 2
+            assert rows[1][1] == "UPDATE"
+            assert "2024-06-20" in rows[1][2]
+            assert "+00:00" in rows[1][2]
+
+            # Row 3: India time (+05:30)
+            assert rows[2][0] == 3
+            assert rows[2][1] == "DELETE"
+            assert "2024-12-01" in rows[2][2]
+            assert "+05:30" in rows[2][2]
+            # NULL value should be None
+            assert rows[2][3] is None
+
+            # Clean up
+            cursor.execute("DROP TABLE test_audit_log")
+            conn.commit()
+
+        finally:
+            conn.close()
+
+    def test_select_star_with_audit_columns(self, mssql_adapter, mssql_config):
+        """Test SELECT * on a typical table with audit timestamp columns.
+
+        This is the most common use case - tables with CreatedAt/ModifiedAt columns.
+        """
+        conn = mssql_adapter.connect(mssql_config)
+
+        try:
+            cursor = conn.cursor()
+
+            cursor.execute("""
+                IF OBJECT_ID('test_entities', 'U') IS NOT NULL
+                    DROP TABLE test_entities
+            """)
+            cursor.execute("""
+                CREATE TABLE test_entities (
+                    id INT IDENTITY(1,1) PRIMARY KEY,
+                    name NVARCHAR(100) NOT NULL,
+                    description NVARCHAR(MAX),
+                    created_at DATETIMEOFFSET DEFAULT SYSDATETIMEOFFSET(),
+                    modified_at DATETIMEOFFSET DEFAULT SYSDATETIMEOFFSET()
+                )
+            """)
+
+            cursor.execute("""
+                INSERT INTO test_entities (name, description) VALUES
+                ('Entity 1', 'First entity'),
+                ('Entity 2', 'Second entity')
+            """)
+            conn.commit()
+
+            # SELECT * should work without errors
+            columns, rows, truncated = mssql_adapter.execute_query(
+                conn, "SELECT * FROM test_entities"
+            )
+
+            assert len(rows) == 2
+            assert len(columns) == 5
+
+            # Verify the datetimeoffset columns are present and formatted
+            for row in rows:
+                created_at = row[3]
+                modified_at = row[4]
+                # Should be non-empty strings with date components
+                assert isinstance(created_at, str)
+                assert isinstance(modified_at, str)
+                assert len(created_at) > 10  # Should have date + time + timezone
+                assert len(modified_at) > 10
+
+            # Clean up
+            cursor.execute("DROP TABLE test_entities")
+            conn.commit()
+
+        finally:
+            conn.close()

tests/test_cockroachdb.py

@@ -20,6 +20,7 @@ def config(self) -> DatabaseTestConfig:
             connection_fixture="cockroachdb_connection",
             db_fixture="cockroachdb_db",
             create_connection_args=lambda: [],  # Uses fixtures
+            timezone_datetime_type="TIMESTAMPTZ",
         )
 
     def test_create_cockroachdb_connection(self, cockroachdb_db, cli_runner):

tests/test_database_base.py

@@ -29,6 +29,9 @@ class DatabaseTestConfig:
     create_connection_args: Callable[..., list[str]]
     # Whether this DB uses LIMIT syntax (False for MSSQL TOP, Oracle FETCH FIRST)
     uses_limit: bool = True
+    # Timezone-aware datetime type name (None if not supported)
+    # e.g., "DATETIMEOFFSET" for MSSQL, "TIMESTAMPTZ" for PostgreSQL
+    timezone_datetime_type: str | None = None
 
 
 class BaseDatabaseTests(ABC):
@@ -822,6 +825,136 @@ def test_get_index_definition(self, request):
             assert isinstance(info, dict), "get_index_definition should return a dict"
             assert "name" in info, "Index info should contain 'name'"
 
+    def test_timezone_aware_datetime(self, request):
+        """Test that timezone-aware datetime columns can be queried.
+
+        This tests that databases with timezone-aware datetime types (like
+        DATETIMEOFFSET, TIMESTAMPTZ, TIMESTAMP WITH TIME ZONE) can be queried
+        without errors. This is important because some drivers (like pyodbc)
+        don't natively support these types and need custom converters.
+
+        See: https://github.com/mkleehammer/pyodbc/issues/134
+        """
+        if self.config.timezone_datetime_type is None:
+            pytest.skip(f"{self.config.display_name} does not have a timezone-aware datetime type")
+
+        from sqlit.config import load_connections
+        from sqlit.db.adapters import get_adapter
+        from sqlit.services.session import ConnectionSession
+
+        connection_name = request.getfixturevalue(self.config.connection_fixture)
+        connections = load_connections()
+        config = next((c for c in connections if c.name == connection_name), None)
+        assert config is not None, f"Connection {connection_name} not found"
+
+        tz_type = self.config.timezone_datetime_type
+
+        with ConnectionSession.create(config, get_adapter) as session:
+            conn = session.connection
+            adapter = session.adapter
+
+            # Create a test table with timezone-aware datetime column
+            # Use a unique table name to avoid conflicts
+            table_name = "test_tz_datetime"
+
+            # Drop table if exists (database-specific syntax)
+            try:
+                if self.config.db_type == "mssql":
+                    adapter.execute_non_query(conn, f"""
+                        IF OBJECT_ID('{table_name}', 'U') IS NOT NULL
+                            DROP TABLE {table_name}
+                    """)
+                elif self.config.db_type == "oracle":
+                    try:
+                        adapter.execute_non_query(conn, f"DROP TABLE {table_name}")
+                    except Exception:
+                        pass  # Table doesn't exist
+                else:
+                    adapter.execute_non_query(conn, f"DROP TABLE IF EXISTS {table_name}")
+            except Exception:
+                pass  # Ignore errors from DROP
+
+            # Create table with timezone-aware datetime
+            if self.config.db_type == "oracle":
+                create_sql = f"""
+                    CREATE TABLE {table_name} (
+                        id NUMBER PRIMARY KEY,
+                        event_name VARCHAR2(100),
+                        event_time {tz_type}
+                    )
+                """
+            else:
+                create_sql = f"""
+                    CREATE TABLE {table_name} (
+                        id INT PRIMARY KEY,
+                        event_name VARCHAR(100),
+                        event_time {tz_type}
+                    )
+                """
+            adapter.execute_non_query(conn, create_sql)
+
+            # Insert test data with timezone info
+            if self.config.db_type == "mssql":
+                insert_sql = f"""
+                    INSERT INTO {table_name} (id, event_name, event_time) VALUES
+                    (1, 'Event UTC', '2024-06-15 12:00:00.000000 +00:00'),
+                    (2, 'Event EST', '2024-06-15 08:00:00.000000 -04:00'),
+                    (3, 'Event IST', '2024-06-15 17:30:00.000000 +05:30')
+                """
+            elif self.config.db_type == "oracle":
+                # Oracle uses different syntax for TIMESTAMP WITH TIME ZONE
+                adapter.execute_non_query(conn, f"""
+                    INSERT INTO {table_name} (id, event_name, event_time) VALUES
+                    (1, 'Event UTC', TIMESTAMP '2024-06-15 12:00:00 +00:00')
+                """)
+                adapter.execute_non_query(conn, f"""
+                    INSERT INTO {table_name} (id, event_name, event_time) VALUES
+                    (2, 'Event EST', TIMESTAMP '2024-06-15 08:00:00 -04:00')
+                """)
+                adapter.execute_non_query(conn, f"""
+                    INSERT INTO {table_name} (id, event_name, event_time) VALUES
+                    (3, 'Event IST', TIMESTAMP '2024-06-15 17:30:00 +05:30')
+                """)
+                insert_sql = None
+            else:
+                # PostgreSQL, CockroachDB, DuckDB use standard syntax
+                insert_sql = f"""
+                    INSERT INTO {table_name} (id, event_name, event_time) VALUES
+                    (1, 'Event UTC', '2024-06-15 12:00:00+00'),
+                    (2, 'Event EST', '2024-06-15 08:00:00-04'),
+                    (3, 'Event IST', '2024-06-15 17:30:00+05:30')
+                """
+
+            if insert_sql:
+                adapter.execute_non_query(conn, insert_sql)
+
+            # Query the table - this is where type -155 errors would occur
+            columns, rows, truncated = adapter.execute_query(
+                conn, f"SELECT * FROM {table_name} ORDER BY id"
+            )
+
+            # Verify we got results
+            assert len(columns) == 3, f"Expected 3 columns, got {len(columns)}"
+            assert len(rows) == 3, f"Expected 3 rows, got {len(rows)}"
+
+            # Verify the data is readable (timezone info should be present in some form)
+            for row in rows:
+                event_time = row[2]
+                assert event_time is not None, "event_time should not be None"
+                # The value should be either a datetime object or a string representation
+                event_time_str = str(event_time)
+                assert "2024" in event_time_str, f"Expected year 2024 in {event_time_str}"
+
+            # Clean up
+            try:
+                if self.config.db_type == "oracle":
+                    adapter.execute_non_query(conn, f"DROP TABLE {table_name}")
+                else:
+                    adapter.execute_non_query(conn, f"DROP TABLE IF EXISTS {table_name}")
+            except Exception:
+                pass
+
+
 class BaseDatabaseTestsWithLimit(BaseDatabaseTests):
     """Base tests for databases that support LIMIT syntax."""