Rollback before close and clean up DateTime passthrough

- AsyncAdaptedConnection.close() now attempts a rollback before
  closing so a NullPool / unpooled async connection that exits
  without an explicit commit does not leave a dangling server-side
  transaction. The underlying rollback is a silent no-op for
  never-used and already-idle connections, so the extra call is
  safe. Rollback failures are suppressed — close is more important
  and proceeds unconditionally.

- Remove the no-op bind_processor/result_processor overrides from
  _DqliteDateTime. They existed only to ensure the generic DateTime's
  literal_processor (which calls ``isoformat()`` directly) is
  selected instead of pysqlite's iso-string-based converter. The
  parent's defaults already return None, so explicit overrides were
  redundant and made _DqliteDate's non-trivial processor look
  stylistically inconsistent for no reason. Replace the overrides
  with a docstring explaining why the class still exists.

Tests:
- tests/test_async_adapter.py adds TestAsyncAdaptedConnectionClose:
  verifies rollback-then-close ordering and verifies close() still
  runs when rollback raises.

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

Author: antoineleclair

src/sqlalchemydqlite/aio.py

@@ -134,6 +134,17 @@ def rollback(self) -> None:
         await_only(self._connection.rollback())
 
     def close(self) -> None:
+        # Attempt rollback before close so a caller that exits without
+        # committing does not leave a dangling server-side transaction
+        # (ISSUE-91). The underlying async connection's rollback is a
+        # silent no-op when no transaction is active and when the
+        # connection has never been used, so the double-call is safe.
+        # Suppress rollback failures — the close is more important and
+        # happens unconditionally below.
+        import contextlib
+
+        with contextlib.suppress(Exception):
+            await_only(self._connection.rollback())
         await_only(self._connection.close())
 
 

src/sqlalchemydqlite/base.py

@@ -19,13 +19,15 @@ 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
+    Inheriting from ``sqltypes.DateTime`` (not ``sqlite.DATETIME``) is
+    deliberate: the generic parent's ``literal_processor`` calls
+    ``value.isoformat()`` directly — bypassing pysqlite's
+    iso-string-based bind processor that would double-convert our
+    already-datetime values (ISSUE-114). The parent's default
+    ``bind_processor`` / ``result_processor`` return ``None`` already,
+    so no explicit overrides are needed here.
+    """
 
 
 class _DqliteDate(sqltypes.Date):

tests/test_async_adapter.py

@@ -101,3 +101,48 @@ def test_executemany_cursor_closed_on_error(self) -> None:
         assert _has_finally_with_close(AsyncAdaptedCursor.executemany), (
             "cursor.close() should be in a finally block to prevent leaks on error"
         )
+
+
+class TestAsyncAdaptedConnectionClose:
+    """ISSUE-91: close() attempts rollback before closing.
+
+    SQLAlchemy's async adapter previously closed the connection without
+    a rollback, leaving any open server-side transaction dangling in
+    unpooled / NullPool usage. Verify rollback is called first, and
+    verify rollback failure does not prevent close.
+    """
+
+    def test_close_attempts_rollback_first(self) -> None:
+        mock_conn = MagicMock()
+        calls: list[str] = []
+        mock_conn.rollback.side_effect = lambda: calls.append("rollback") or object()
+        mock_conn.close.side_effect = lambda: calls.append("close") or object()
+
+        adapted = AsyncAdaptedConnection.__new__(AsyncAdaptedConnection)
+        adapted._connection = mock_conn
+
+        with patch("sqlalchemydqlite.aio.await_only", side_effect=_run_sync):
+            adapted.close()
+
+        assert calls == ["rollback", "close"], f"Expected rollback then close, got {calls}"
+
+    def test_close_proceeds_when_rollback_raises(self) -> None:
+        """A failing rollback (e.g. connection already in a bad state)
+        must not block close — resource cleanup is more important."""
+        mock_conn = MagicMock()
+        calls: list[str] = []
+
+        def failing_rollback() -> None:
+            calls.append("rollback-attempt")
+            raise RuntimeError("simulated rollback failure")
+
+        mock_conn.rollback.side_effect = failing_rollback
+        mock_conn.close.side_effect = lambda: calls.append("close") or object()
+
+        adapted = AsyncAdaptedConnection.__new__(AsyncAdaptedConnection)
+        adapted._connection = mock_conn
+
+        with patch("sqlalchemydqlite.aio.await_only", side_effect=_run_sync):
+            adapted.close()  # must not raise
+
+        assert "close" in calls, "close() must run even if rollback raised"