Override DATETIME/DATE colspecs for native datetime passthrough

The dqlite DBAPI now returns datetime.datetime directly for columns the
server tags as ISO8601 or UNIXTIME (matching psycopg/mysqlclient/PEP 249).
SQLAlchemy's inherited sqlite.DATETIME and sqlite.DATE types, by contrast,
assume pysqlite-style string returns and call fromisoformat on the value —
which crashes when handed a datetime.

Registers two dialect-local types via colspecs:
- _DqliteDateTime: bind_processor and result_processor both return None,
  so datetime objects flow through unchanged in both directions (the
  DBAPI stringifies on bind and datetime-ifies on result).
- _DqliteDate: bind is passthrough; result narrows datetime.datetime to
  datetime.date on read, since the server tags DATE columns as ISO8601
  (see dqlite-upstream/src/query.c) and the DBAPI doesn't know to
  downcast.

TIME is deliberately not overridden: the server does not tag TIME columns
specially (they're plain TEXT), so SQLAlchemy's string-based Time
processor continues to work as-is.

Async dialect (aio.DqliteDialect_aio) inherits colspecs from the sync
dialect, so it picks up the overrides automatically.

Tests tightened and extended in test_orm_operations.py: the existing
test_datetime_types now asserts tzinfo-is-None and full value equality
(not just field-by-field). New tests cover Column(Date) returning
datetime.date exactly (not a datetime subclass) and NULL DateTime
round-trip.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/sqlalchemydqlite/base.py

@@ -1,12 +1,47 @@
 """Base dqlite dialect for SQLAlchemy."""
 
+import datetime
 from typing import Any
 
+from sqlalchemy import types as sqltypes
 from sqlalchemy.dialects.sqlite.base import SQLiteDialect
 from sqlalchemy.engine import URL
 from sqlalchemy.engine.interfaces import DBAPIConnection, IsolationLevel
 
 
+class _DqliteDateTime(sqltypes.DateTime):
+    """Passthrough DateTime — ``dqlitedbapi`` already returns ``datetime.datetime``
+    for columns declared as DATETIME/TIMESTAMP (matching PEP 249 and the
+    psycopg/mysqlclient convention), so no string parsing is needed.
+    """
+
+    def bind_processor(self, dialect: Any) -> None:
+        return None
+
+    def result_processor(self, dialect: Any, coltype: Any) -> None:
+        return None
+
+
+class _DqliteDate(sqltypes.Date):
+    """Passthrough Date — ``dqlitedbapi`` returns ``datetime.datetime`` for
+    DATE columns (the C server tags all of DATETIME/DATE/TIMESTAMP as
+    ``DQLITE_ISO8601``); narrow to ``datetime.date`` on read.
+    """
+
+    def bind_processor(self, dialect: Any) -> None:
+        return None
+
+    def result_processor(
+        self, dialect: Any, coltype: Any
+    ) -> Any:
+        def process(value: Any) -> Any:
+            if isinstance(value, datetime.datetime):
+                return value.date()
+            return value
+
+        return process
+
+
 class DqliteDialect(SQLiteDialect):
     """SQLAlchemy dialect for dqlite.
 
@@ -22,6 +57,14 @@ class DqliteDialect(SQLiteDialect):
     # Enable SQLAlchemy statement caching
     supports_statement_cache = True
 
+    # Override the SQLite dialect's string-based DATE/DATETIME processors:
+    # dqlitedbapi returns datetime objects (PEP 249), not ISO strings.
+    colspecs = {
+        **SQLiteDialect.colspecs,
+        sqltypes.DateTime: _DqliteDateTime,
+        sqltypes.Date: _DqliteDate,
+    }
+
     @classmethod
     def import_dbapi(cls) -> Any:
         import dqlitedbapi

tests/integration/test_orm_operations.py

@@ -8,6 +8,7 @@
     BigInteger,
     Boolean,
     Column,
+    Date,
     DateTime,
     Float,
     Integer,
@@ -63,6 +64,13 @@ class DateTimeTest(Base):  # type: ignore[valid-type,misc]
     updated_at = Column(DateTime, nullable=True)
 
 
+class DateOnlyTest(Base):  # type: ignore[valid-type,misc]
+    __tablename__ = "date_only_test"
+
+    id = Column(Integer, primary_key=True)
+    d = Column(Date)
+
+
 @pytest.mark.integration
 class TestORMOperations:
     @pytest.fixture
@@ -192,12 +200,41 @@ def test_datetime_types(self, engine: Engine) -> None:
                 result = session.query(DateTimeTest).order_by(DateTimeTest.id.desc()).first()
                 assert result is not None
 
-                assert result.created_at.year == dt.year
-                assert result.created_at.month == dt.month
-                assert result.created_at.day == dt.day
-                assert result.created_at.hour == dt.hour
-                assert result.created_at.minute == dt.minute
-                assert result.created_at.second == dt.second
+                assert isinstance(result.created_at, datetime.datetime)
+                # SQLAlchemy's default DateTime is timezone=False, so naive
+                # input must round-trip as naive (not silently UTC-tagged).
+                assert result.created_at.tzinfo is None
+                assert result.created_at == dt
+
+    def test_datetime_null_roundtrip(self, engine: Engine) -> None:
+        """A NULL DateTime column reads back as None."""
+        with Session(engine) as session:
+            record = DateTimeTest(
+                created_at=datetime.datetime(2024, 1, 1, 0, 0, 0),
+                updated_at=None,
+            )
+            session.add(record)
+            session.commit()
+
+            result = session.query(DateTimeTest).order_by(DateTimeTest.id.desc()).first()
+            assert result is not None
+            assert result.updated_at is None
+
+    def test_date_column_returns_date(self, engine: Engine) -> None:
+        """A Column(Date) returns ``datetime.date``, not ``datetime.datetime``.
+
+        The dqlite DBAPI returns datetime for ISO8601-tagged columns; the
+        dialect's _DqliteDate.result_processor narrows to date on read.
+        """
+        d = datetime.date(2024, 3, 14)
+        with Session(engine) as session:
+            session.add(DateOnlyTest(d=d))
+            session.commit()
+
+            result = session.query(DateOnlyTest).order_by(DateOnlyTest.id.desc()).first()
+            assert result is not None
+            assert type(result.d) is datetime.date
+            assert result.d == d
 
     def test_null_handling(self, engine: Engine) -> None:
         """Test NULL values across different column types."""