Support sqlite3.connect(autocommit=False) connections too

Database() now accepts all three Python transaction handling modes and
behaves identically in each. For autocommit=False connections - where
the driver holds an implicit transaction open at all times - the
library tracks transaction ownership itself:

- A new _explicit_transaction flag distinguishes transactions opened
  with begin()/atomic() from the driver's implicit one, exposed as a
  new db.in_transaction property (conn.in_transaction is always True
  in this mode)
- begin() claims the driver's implicit transaction instead of
  executing BEGIN, which the driver would reject; BEGIN/COMMIT/
  ROLLBACK passed to db.execute() are routed through begin()/commit()/
  rollback()
- Writes outside a user transaction commit the implicit transaction
  immediately, preserving the library's auto-commit contract
- Row-returning statements outside a transaction fetch eagerly and
  commit, so the implicit read transaction does not hold a shared
  lock that blocks writes from other connections
- PRAGMA and VACUUM run in temporary driver autocommit mode
  (ensure_autocommit_on() now flips conn.autocommit), since PRAGMAs
  are silently ignored and VACUUM refused inside the implicit
  transaction

A new pytest --sqlite-autocommit-false option runs the entire suite
in this mode, wired into CI alongside --sqlite-autocommit. Tests that
asserted on conn.in_transaction or wrote through db.conn without
committing now use the mode-aware library API instead.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PFkrS2nuP8mo1jmT594VCd

tests/test_query.py

@@ -24,14 +24,14 @@ def test_query_rejects_statements_that_return_no_rows(fresh_db):
         fresh_db.query("update dogs set name = 'Cleopaws'")
     assert "execute()" in str(ex.value)
     # The rejected update was rolled back, and no transaction is left open
-    assert not fresh_db.conn.in_transaction
+    assert not fresh_db.in_transaction
     assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
 
 
 def test_query_rejected_ddl_is_rolled_back(fresh_db):
     with pytest.raises(ValueError):
         fresh_db.query("create table dogs (id integer primary key)")
-    assert not fresh_db.conn.in_transaction
+    assert not fresh_db.in_transaction
     assert fresh_db.table_names() == []
 
 
@@ -42,7 +42,7 @@ def test_query_rejected_write_inside_transaction_is_rolled_back(fresh_db):
     with pytest.raises(ValueError):
         fresh_db.query("update dogs set name = 'Cleopaws'")
     # The transaction is still open and the earlier insert is intact
-    assert fresh_db.conn.in_transaction
+    assert fresh_db.in_transaction
     fresh_db.commit()
     assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo", "Pancakes"]
 
@@ -69,7 +69,7 @@ def test_query_rejects_transaction_control_and_vacuum(fresh_db, sql):
     with pytest.raises(ValueError) as ex:
         fresh_db.query(sql)
     assert "execute()" in str(ex.value)
-    assert not fresh_db.conn.in_transaction
+    assert not fresh_db.in_transaction
 
 
 def test_query_comment_prefixed_commit_does_not_commit_transaction(fresh_db):
@@ -82,7 +82,7 @@ def test_query_comment_prefixed_commit_does_not_commit_transaction(fresh_db):
     with pytest.raises(ValueError):
         fresh_db.query("/* comment */ COMMIT")
     # The explicit transaction is still open and can still be rolled back
-    assert fresh_db.conn.in_transaction
+    assert fresh_db.in_transaction
     fresh_db.rollback()
     assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
 
@@ -99,7 +99,7 @@ def test_query_prefixed_commit_does_not_commit_transaction(fresh_db, sql):
     with pytest.raises(ValueError):
         fresh_db.query(sql)
     # The explicit transaction is still open and can still be rolled back
-    assert fresh_db.conn.in_transaction
+    assert fresh_db.in_transaction
     fresh_db.rollback()
     assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
 
@@ -107,7 +107,7 @@ def test_query_prefixed_commit_does_not_commit_transaction(fresh_db, sql):
 def test_query_error_leaves_no_transaction_open(fresh_db):
     with pytest.raises(sqlite3.OperationalError):
         fresh_db.query("select * from missing_table")
-    assert not fresh_db.conn.in_transaction
+    assert not fresh_db.in_transaction
 
 
 def test_query_pragma(tmpdir):
@@ -152,7 +152,7 @@ def test_query_comment_prefixed_pragma_inside_transaction(fresh_db):
     assert list(fresh_db.query("-- check version\npragma user_version")) == [
         {"user_version": 0}
     ]
-    assert fresh_db.conn.in_transaction
+    assert fresh_db.in_transaction
     fresh_db.rollback()
 
 
@@ -209,7 +209,7 @@ def test_query_insert_returning_commits_without_iteration(tmpdir):
     db["dogs"].insert({"name": "Cleo"})
     # Never iterate over the results
     db.query("insert into dogs (name) values ('Pancakes') returning name")
-    assert not db.conn.in_transaction
+    assert not db.in_transaction
     # A completely separate connection sees the new row straight away
     other = sqlite3.connect(path)
     assert other.execute("select count(*) from dogs").fetchone()[0] == 2
@@ -233,7 +233,7 @@ def test_query_insert_returning_partial_iteration_still_commits(tmpdir):
         )
     )
     assert row == {"name": "Pancakes"}
-    assert not db.conn.in_transaction
+    assert not db.in_transaction
     other = sqlite3.connect(path)
     assert other.execute("select count(*) from dogs").fetchone()[0] == 3
     other.close()
@@ -252,7 +252,7 @@ def test_query_insert_returning_respects_explicit_transaction(fresh_db):
     )
     assert rows == [{"name": "Pancakes"}]
     # Still inside the explicit transaction - not committed
-    assert fresh_db.conn.in_transaction
+    assert fresh_db.in_transaction
     fresh_db.rollback()
     assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
 
@@ -299,5 +299,5 @@ def test_query_preserves_error_from_transaction_destroying_trigger(fresh_db):
     """)
     with pytest.raises(sqlite3.IntegrityError, match="trigger says no"):
         fresh_db.query("insert into t (id, v) values (1, 'bad') returning id")
-    assert not fresh_db.conn.in_transaction
+    assert not fresh_db.in_transaction
     assert fresh_db.execute("select count(*) from t").fetchone()[0] == 0