Take the connection mutex around more SQLite getters

SQLite 3.53, which the Windows build bundles, also takes the connection
mutex in sqlite3_limit(), sqlite3_get_autocommit(), sqlite3_changes(),
sqlite3_total_changes() and sqlite3_errcode().

Author: gpshead

Lib/test/test_sqlite3/test_dbapi.py

@@ -1833,6 +1833,9 @@ def collation(cx):
                 lambda cx: cx.set_trace_callback(None))
             run("setconfig", sql, function,
                 lambda cx: cx.setconfig(sqlite3.SQLITE_DBCONFIG_ENABLE_FKEY))
+            run("getters", sql, function,
+                lambda cx: (cx.in_transaction, cx.total_changes,
+                            cx.getlimit(sqlite3.SQLITE_LIMIT_LENGTH)))
             print("done")
         """)
         try:

Modules/_sqlite/connection.c

@@ -454,7 +454,7 @@ connection_close(pysqlite_Connection *self)
 
     int rc = 0;
     if (self->autocommit == AUTOCOMMIT_DISABLED &&
-        !sqlite3_get_autocommit(self->db))
+        !pysqlite_get_autocommit(self->db))
     {
         if (connection_exec_stmt(self, "ROLLBACK") < 0) {
             rc = -1;
@@ -759,7 +759,7 @@ pysqlite_connection_commit_impl(pysqlite_Connection *self)
     }
 
     if (self->autocommit == AUTOCOMMIT_LEGACY) {
-        if (!sqlite3_get_autocommit(self->db)) {
+        if (!pysqlite_get_autocommit(self->db)) {
             if (connection_exec_stmt(self, "COMMIT") < 0) {
                 return NULL;
             }
@@ -793,7 +793,7 @@ pysqlite_connection_rollback_impl(pysqlite_Connection *self)
     }
 
     if (self->autocommit == AUTOCOMMIT_LEGACY) {
-        if (!sqlite3_get_autocommit(self->db)) {
+        if (!pysqlite_get_autocommit(self->db)) {
             if (connection_exec_stmt(self, "ROLLBACK") < 0) {
                 return NULL;
             }
@@ -1184,7 +1184,7 @@ destructor_callback(void *ctx)
 static int
 check_num_params(pysqlite_Connection *self, const int n, const char *name)
 {
-    int limit = sqlite3_limit(self->db, SQLITE_LIMIT_FUNCTION_ARG, -1);
+    int limit = pysqlite_limit(self->db, SQLITE_LIMIT_FUNCTION_ARG, -1);
     assert(limit >= 0);
     if (n < -1 || n > limit) {
         PyErr_Format(self->ProgrammingError,
@@ -1838,7 +1838,10 @@ pysqlite_connection_get_total_changes(PyObject *op, void *Py_UNUSED(closure))
     if (!pysqlite_check_connection(self)) {
         return NULL;
     }
-    return PyLong_FromLong(sqlite3_total_changes(self->db));
+    pysqlite_db_mutex_enter(self->db);
+    int changes = sqlite3_total_changes(self->db);
+    pysqlite_db_mutex_leave(self->db);
+    return PyLong_FromLong(changes);
 }
 
 static PyObject *
@@ -1848,7 +1851,7 @@ pysqlite_connection_get_in_transaction(PyObject *op, void *Py_UNUSED(closure))
     if (!pysqlite_check_connection(self)) {
         return NULL;
     }
-    if (!sqlite3_get_autocommit(self->db)) {
+    if (!pysqlite_get_autocommit(self->db)) {
         Py_RETURN_TRUE;
     }
     Py_RETURN_FALSE;
@@ -2508,7 +2511,7 @@ setlimit_impl(pysqlite_Connection *self, int category, int limit)
         return NULL;
     }
 
-    int old_limit = sqlite3_limit(self->db, category, limit);
+    int old_limit = pysqlite_limit(self->db, category, limit);
     if (old_limit < 0) {
         PyErr_SetString(self->ProgrammingError, "'category' is out of bounds");
         return NULL;
@@ -2679,14 +2682,14 @@ set_autocommit(PyObject *op, PyObject *val, void *Py_UNUSED(closure))
         return -1;
     }
     if (self->autocommit == AUTOCOMMIT_ENABLED) {
-        if (!sqlite3_get_autocommit(self->db)) {
+        if (!pysqlite_get_autocommit(self->db)) {
             if (connection_exec_stmt(self, "COMMIT") < 0) {
                 return -1;
             }
         }
     }
     else if (self->autocommit == AUTOCOMMIT_DISABLED) {
-        if (sqlite3_get_autocommit(self->db)) {
+        if (pysqlite_get_autocommit(self->db)) {
             if (connection_exec_stmt(self, "BEGIN") < 0) {
                 return -1;
             }

Modules/_sqlite/cursor.c

@@ -937,7 +937,7 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* operation
     if (self->connection->autocommit == AUTOCOMMIT_LEGACY
         && self->connection->isolation_level
         && self->statement->is_dml
-        && sqlite3_get_autocommit(self->connection->db))
+        && pysqlite_get_autocommit(self->connection->db))
     {
         if (begin_transaction(self->connection) < 0) {
             goto error;
@@ -1025,7 +1025,9 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* operation
 
         if (rc == SQLITE_DONE) {
             if (self->statement->is_dml) {
-                self->rowcount += (long)sqlite3_changes(self->connection->db);
+                pysqlite_db_mutex_enter(db);
+                self->rowcount += (long)sqlite3_changes(db);
+                pysqlite_db_mutex_leave(db);
             }
             if (stmt_reset(self->statement) != SQLITE_OK) {
                 goto reset_failure;
@@ -1059,7 +1061,9 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* operation
     if (PyErr_Occurred()) {
         if (self->statement) {
             sqlite3 *db = sqlite3_db_handle(self->statement->st);
+            pysqlite_db_mutex_enter(db);
             int sqlite3_state = sqlite3_errcode(db);
+            pysqlite_db_mutex_leave(db);
             // stmt_reset() may return a previously set exception,
             // either triggered because of Python or sqlite3.
             rc = stmt_reset(self->statement);
@@ -1146,8 +1150,8 @@ pysqlite_cursor_executescript_impl(pysqlite_Cursor *self,
     }
 
     size_t sql_len = strlen(sql_script);
-    int max_length = sqlite3_limit(self->connection->db,
-                                   SQLITE_LIMIT_SQL_LENGTH, -1);
+    int max_length = pysqlite_limit(self->connection->db,
+                                    SQLITE_LIMIT_SQL_LENGTH, -1);
     if (sql_len > (unsigned)max_length) {
         PyErr_SetString(self->connection->DataError,
                         "query string is too large");
@@ -1157,7 +1161,7 @@ pysqlite_cursor_executescript_impl(pysqlite_Cursor *self,
     // Commit if needed
     sqlite3 *db = self->connection->db;
     if (self->connection->autocommit == AUTOCOMMIT_LEGACY
-        && !sqlite3_get_autocommit(db))
+        && !pysqlite_get_autocommit(db))
     {
         int rc = SQLITE_OK;
 
@@ -1229,7 +1233,10 @@ pysqlite_cursor_iternext(PyObject *op)
     int rc = stmt_step(stmt);
     if (rc == SQLITE_DONE) {
         if (self->statement->is_dml) {
-            self->rowcount = (long)sqlite3_changes(self->connection->db);
+            sqlite3 *db = self->connection->db;
+            pysqlite_db_mutex_enter(db);
+            self->rowcount = (long)sqlite3_changes(db);
+            pysqlite_db_mutex_leave(db);
         }
         rc = stmt_reset(self->statement);
         Py_CLEAR(self->statement);

Modules/_sqlite/statement.c

@@ -49,7 +49,7 @@ pysqlite_statement_create(pysqlite_Connection *connection, PyObject *sql)
     }
 
     sqlite3 *db = connection->db;
-    int max_length = sqlite3_limit(db, SQLITE_LIMIT_SQL_LENGTH, -1);
+    int max_length = pysqlite_limit(db, SQLITE_LIMIT_SQL_LENGTH, -1);
     if (size > max_length) {
         PyErr_SetString(connection->DataError,
                         "query string is too large");

Modules/_sqlite/util.c

@@ -141,17 +141,18 @@ set_error_from_code(pysqlite_state *state, int code)
 int
 set_error_from_db(pysqlite_state *state, sqlite3 *db)
 {
+    pysqlite_db_mutex_enter(db);
     int errorcode = sqlite3_errcode(db);
     PyObject *exc_class = get_exception_class(state, errorcode);
     if (exc_class == NULL) {
         // No new exception need be raised.
+        pysqlite_db_mutex_leave(db);
         return SQLITE_OK;
     }
 
     /* Create and set the exception. */
     int extended_errcode = sqlite3_extended_errcode(db);
     // sqlite3_errmsg() always returns an UTF-8 encoded message
-    pysqlite_db_mutex_enter(db);
     PyObject *errmsg = PyUnicode_FromString(sqlite3_errmsg(db));
     pysqlite_db_mutex_leave(db);
     raise_exception(exc_class, extended_errcode, errmsg);

Modules/_sqlite/util.h

@@ -66,7 +66,10 @@ pysqlite_set_ref(PyObject *owner, PyObject **field, PyObject *value)
  * never block on the connection mutex while holding the GIL: enter the mutex
  * with these helpers around SQLite API calls that take it and are made with
  * the GIL held.  The mutex is recursive, and it is NULL unless SQLite is in
- * serialized threading mode.
+ * serialized threading mode.  Newer SQLite versions take the mutex in more
+ * calls, including getters such as sqlite3_get_autocommit() and
+ * sqlite3_limit(), so assume that any call on a connection or a statement
+ * takes it unless the SQLite documentation says otherwise.
  *
  * Do not call back into Python code while holding the mutex: it could wait
  * for another thread that is blocked on the same mutex. */
@@ -109,4 +112,22 @@ pysqlite_db_mutex_leave(sqlite3 *db)
     pysqlite_mutex_leave(sqlite3_db_mutex(db));
 }
 
+static inline int
+pysqlite_get_autocommit(sqlite3 *db)
+{
+    pysqlite_db_mutex_enter(db);
+    int autocommit = sqlite3_get_autocommit(db);
+    pysqlite_db_mutex_leave(db);
+    return autocommit;
+}
+
+static inline int
+pysqlite_limit(sqlite3 *db, int id, int new_value)
+{
+    pysqlite_db_mutex_enter(db);
+    int old_value = sqlite3_limit(db, id, new_value);
+    pysqlite_db_mutex_leave(db);
+    return old_value;
+}
+
 #endif