Move cross-thread state access to event loop thread

- commit()/rollback(): Move _async_conn None-check into _commit_async/
  _rollback_async which run on the event loop thread. Remove
  _get_async_connection() calls that would create spurious connections.
- close(): Move _async_conn handling into _close_async() coroutine.
  Acquire _loop_lock for loop teardown to prevent races with
  _ensure_loop().

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

Author: antoineleclair

src/dqlitedbapi/connection.py

@@ -118,46 +118,50 @@ def close(self) -> None:
             return
         self._closed = True
         try:
-            if self._async_conn is not None:
+            if self._loop is not None and not self._loop.is_closed():
                 with contextlib.suppress(Exception):
-                    self._run_sync(self._async_conn.close())
-                self._async_conn = None
+                    self._run_sync(self._close_async())
         finally:
-            if self._loop is not None and not self._loop.is_closed():
-                self._loop.call_soon_threadsafe(self._loop.stop)
-                if self._thread is not None:
-                    self._thread.join(timeout=5)
-                self._loop.close()
-                self._loop = None
-                self._thread = None
+            with self._loop_lock:
+                if self._loop is not None and not self._loop.is_closed():
+                    self._loop.call_soon_threadsafe(self._loop.stop)
+                    if self._thread is not None:
+                        self._thread.join(timeout=5)
+                    self._loop.close()
+                    self._loop = None
+                    self._thread = None
+
+    async def _close_async(self) -> None:
+        """Async implementation of close -- runs on event loop thread."""
+        if self._async_conn is not None:
+            try:
+                await self._async_conn.close()
+            finally:
+                self._async_conn = None
 
     def commit(self) -> None:
         """Commit any pending transaction."""
         self._check_thread()
         if self._closed:
             raise InterfaceError("Connection is closed")
-
-        if self._async_conn is not None:
-            self._run_sync(self._commit_async())
+        self._run_sync(self._commit_async())
 
     async def _commit_async(self) -> None:
         """Async implementation of commit."""
-        conn = await self._get_async_connection()
-        await conn.execute("COMMIT")
+        if self._async_conn is not None:
+            await self._async_conn.execute("COMMIT")
 
     def rollback(self) -> None:
         """Roll back any pending transaction."""
         self._check_thread()
         if self._closed:
             raise InterfaceError("Connection is closed")
-
-        if self._async_conn is not None:
-            self._run_sync(self._rollback_async())
+        self._run_sync(self._rollback_async())
 
     async def _rollback_async(self) -> None:
         """Async implementation of rollback."""
-        conn = await self._get_async_connection()
-        await conn.execute("ROLLBACK")
+        if self._async_conn is not None:
+            await self._async_conn.execute("ROLLBACK")
 
     def cursor(self) -> Cursor:
         """Return a new Cursor object."""

tests/test_commit_no_spurious_connect.py

@@ -0,0 +1,72 @@
+"""Tests that commit/rollback don't create spurious connections.
+
+If commit() or rollback() is called on a connection that was never used
+(no execute() was called), it should be a no-op. It should NOT create a
+new TCP connection just to send COMMIT/ROLLBACK.
+"""
+
+from unittest.mock import AsyncMock, patch
+
+from dqlitedbapi.connection import Connection
+
+
+class TestCommitNoSpuriousConnect:
+    def test_commit_on_unused_connection_is_noop(self) -> None:
+        """commit() should not create a connection if none exists."""
+        conn = Connection("localhost:9001", timeout=2.0)
+
+        with patch.object(conn, "_get_async_connection") as mock_get:
+            mock_get.return_value = AsyncMock()
+            conn.commit()
+            mock_get.assert_not_called()
+
+        conn.close()
+
+    def test_rollback_on_unused_connection_is_noop(self) -> None:
+        """rollback() should not create a connection if none exists."""
+        conn = Connection("localhost:9001", timeout=2.0)
+
+        with patch.object(conn, "_get_async_connection") as mock_get:
+            mock_get.return_value = AsyncMock()
+            conn.rollback()
+            mock_get.assert_not_called()
+
+        conn.close()
+
+
+class TestCommitRollbackAsyncNoSpuriousConnect:
+    def test_commit_async_does_not_call_get_async_connection(self) -> None:
+        """_commit_async should check _async_conn directly, not call _get_async_connection."""
+        import ast
+        import inspect
+        import textwrap
+
+        source = textwrap.dedent(inspect.getsource(Connection._commit_async))
+        tree = ast.parse(source)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                func = node.func
+                if isinstance(func, ast.Attribute) and func.attr == "_get_async_connection":
+                    raise AssertionError(
+                        "_commit_async calls _get_async_connection which creates "
+                        "new connections. It should check _async_conn directly."
+                    )
+
+    def test_rollback_async_does_not_call_get_async_connection(self) -> None:
+        """_rollback_async should check _async_conn directly, not call _get_async_connection."""
+        import ast
+        import inspect
+        import textwrap
+
+        source = textwrap.dedent(inspect.getsource(Connection._rollback_async))
+        tree = ast.parse(source)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                func = node.func
+                if isinstance(func, ast.Attribute) and func.attr == "_get_async_connection":
+                    raise AssertionError(
+                        "_rollback_async calls _get_async_connection which creates "
+                        "new connections. It should check _async_conn directly."
+                    )