python
@@ -23,8 +23,10 @@
 import threading
 import unittest
 import sqlite3 as sqlite
+import subprocess
 import sys
 
+from test.support import SHORT_TIMEOUT
 from test.support.os_helper import TESTFN, unlink
 
 
@@ -933,6 +935,72 @@ def test_on_conflict_replace(self):
         self.assertEqual(self.cu.fetchall(), [('Very different data!', 'foo')])
 
 
+class MultiprocessTests(unittest.TestCase):
+    def setUp(self):
+        with sqlite.connect(TESTFN) as cx:
+            cx.execute("create table t(t)")
+
+    def tearDown(self):
+        unlink(TESTFN)
+
+    def test_rollback_if_db_is_locked(self):
+        # bpo-27334: ctx manager does not rollback if commit fails
+        TIMEOUT = 0.01
+        SCRIPT = f"""if 1:
+            import sqlite3
+            input()  # wait for parent process to start
+            cx = sqlite3.connect("{TESTFN}", timeout={TIMEOUT})
+            try:
+                with cx:
+                    cx.execute("insert into t values('test')")
+            except Exception as exc:
+                print(exc)
+            else:
+                print("no error in sub")
+            input()  # keep proc open till parent calls
+        """
+
+        # spawn child process
+        proc = subprocess.Popen(
+            [sys.executable, "-c", SCRIPT],
+            encoding="utf-8",
+            bufsize=0,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        self.addCleanup(proc.communicate)
+
+        # connect to db, and create a UDF that waits for child
+        cx = sqlite.connect(TESTFN, timeout=TIMEOUT)
+        def wait():
+            proc.stdin.write("\n")  # tell child to connect
+            self.assertIn("database is locked", proc.stdout.readline())
+        cx.create_function("wait", 0, wait)
+
+        # execute two transactions; both will try to lock the db
+        cx.executescript("""
+            -- execute a transaction and wait for child
+            begin transaction;
+            select * from t;
+            select wait();
+            rollback;
+
+            -- start a new transaction; will fail if child holds lock
+            begin transaction;
+            select * from t;
+            rollback;
+        """)
+
+        # terminate child process
+        self.assertIsNone(proc.returncode)
+        try:
+            proc.communicate(input="\n", timeout=SHORT_TIMEOUT)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            proc.communicate()
+
+
 def suite():
     tests = [
         ClosedConTests,
@@ -942,6 +1010,7 @@ def suite():
         CursorTests,
         ExtensionTests,
         ModuleTests,
+        MultiprocessTests,
         SqliteOnConflictTests,
         ThreadTests,
     ]

diff --git a/Misc/NEWS.d/next/Library/2021-05-18-00-17-21.bpo-27334.32EJZi.rst b/Misc/NEWS.d/next/Library/2021-05-18-00-17-21.bpo-27334.32EJZi.rst
@@ -0,0 +1,2 @@
+The :mod:`sqlite3` context manager now releases the database lock if the
+implicit ``COMMIT`` fails. Patch by Luca Citi and Erlend E. Aasland.
@@ -1839,17 +1839,30 @@ pysqlite_connection_exit_impl(pysqlite_Connection *self, PyObject *exc_type,
                               PyObject *exc_value, PyObject *exc_tb)
 /*[clinic end generated code: output=0705200e9321202a input=bd66f1532c9c54a7]*/
 {
-    const char* method_name;
+    int commit = 0;
     PyObject* result;
 
     if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
-        method_name = "commit";
+        commit = 1;
+        result = pysqlite_connection_commit_impl(self);
     } else {
-        method_name = "rollback";
+        result = pysqlite_connection_rollback_impl(self);
     }
 
-    result = PyObject_CallMethod((PyObject*)self, method_name, NULL);
     if (!result) {
+        if (commit) {
+            /* If commit failed, rollback and keep the existing exception. If
+             * rollback also fails, overwrite the exception. We use
+             * sqlite3_exec() to avoid accidentally clearing the current
+             * exception when rolling back. */
+            int rc;
+            Py_BEGIN_ALLOW_THREADS
+            rc = sqlite3_exec(self->db, "rollback;", NULL, NULL, NULL);
+            Py_END_ALLOW_THREADS
+            if (rc != SQLITE_OK && !PyErr_Occurred()) {
+                _pysqlite_seterror(self->db);
+            }
+        }
         return NULL;
     }
     Py_DECREF(result);
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		The :mod:`sqlite3` context manager now releases the database lock if the
Comment thread erlend-aasland marked this conversation as resolved. Outdated
		implicit ``COMMIT`` fails. Patch by Luca Citi and Erlend E. Aasland.