bpo-45613: Set sqlite3.threadsafety dynamically

Doc/library/sqlite3.rst

@@ -159,23 +159,41 @@ Module functions and constants
 
 .. data:: threadsafety
 
- Integer constant required by the DB-API, stating the level of thread safety
- the :mod:`sqlite3` module supports. Currently hard-coded to ``1``, meaning
- *"Threads may share the module, but not connections."* However, this may not
- always be true. You can check the underlying SQLite library's compile-time
- threaded mode using the following query::
-
- import sqlite3
- con = sqlite3.connect(":memory:")
- con.execute("""
- select * from pragma_compile_options
- where compile_options like 'THREADSAFE=%'
- """).fetchall()
-
- Note that the `SQLITE_THREADSAFE levels
- <https://sqlite.org/compile.html#threadsafe>`_ do not match the DB-API 2.0
- ``threadsafety`` levels.
-
+ Integer constant required by the DB-API 2.0, stating the level of thread
+ safety the :mod:`sqlite3` module supports. This attribute is set based on
+ the default `threading mode <https://sqlite.org/threadsafe.html>`_ the
+ underlying SQLite library is compiled with. The SQLite threading modes are:
+
+ 1. **Single-thread**: In this mode, all mutexes are disabled and SQLite is
+ unsafe to use in more than a single thread at once.
+ 2. **Multi-thread**: In this mode, SQLite can be safely used by multiple
+ threads provided that no single database connection is used
+ simultaneously in two or more threads.
+ 3. **Serialized**: In serialized mode, SQLite can be safely used by
+ multiple threads with no restriction.
+
+ The mappings from SQLite threading modes to DB-API 2.0 threadsafety levels
+ are as follows:
+
+ +------------------+-----------------+----------------------+-------------------------------+
+ | SQLite threading | `threadsafety`_ | `SQLITE_THREADSAFE`_ | DB-API 2.0 meaning |
+ | mode | | | |
+ +==================+=================+======================+===============================+
+ | single-thread | 0 | 0 | Threads may not share the |
+ | | | | module |
+ +------------------+-----------------+----------------------+-------------------------------+
+ | multi-thread | 1 | 2 | Threads may share the module, |
+ | | | | but not connections |
+ +------------------+-----------------+----------------------+-------------------------------+
+ | serialized | 3 | 1 | Threads may share the module, |
+ | | | | connections and cursors |
+ +------------------+-----------------+----------------------+-------------------------------+
+
+ .. _threadsafety: https://www.python.org/dev/peps/pep-0249/#threadsafety
+ .. _SQLITE_THREADSAFE: https://sqlite.org/compile.html#threadsafe
+
+ .. versionchanged:: 3.11
+ Set *threadsafety* dynamically instead of hard-coding it to ``1``.
 
 .. data:: PARSE_DECLTYPES
 

Doc/whatsnew/3.11.rst

@@ -253,6 +253,10 @@ sqlite3
  setting and getting SQLite limits by connection basis.
  (Contributed by Erlend E. Aasland in :issue:`45243`.)
 
+* :mod:`sqlite3` now sets :attr:`sqlite3.threadsafety` based on the default
+ threading mode the underlying SQLite library has been compiled with.
+ (Contributed by Erlend E. Aasland in :issue:`45613`.)
+
 
 threading
 ---------

Lib/sqlite3/dbapi2.py

@@ -28,8 +28,6 @@
 
 paramstyle = "qmark"
 
-threadsafety = 1
-
 apilevel = "2.0"
 
 Date = datetime.date

Lib/test/test_sqlite3/test_dbapi.py

@@ -54,8 +54,9 @@ def test_api_level(self):
  "apilevel is %s, should be 2.0" % sqlite.apilevel)
 
  def test_thread_safety(self):
- self.assertEqual(sqlite.threadsafety, 1,
- "threadsafety is %d, should be 1" % sqlite.threadsafety)
+ self.assertIn(sqlite.threadsafety, {0, 1, 3},
+ "threadsafety is %d, should be 0, 1 or 3" %
+ sqlite.threadsafety)
 
  def test_param_style(self):
  self.assertEqual(sqlite.paramstyle, "qmark",

Misc/NEWS.d/next/Library/2021-10-26-14-29-54.bpo-45613.55Ie3c.rst

@@ -0,0 +1,3 @@
+:mod:`sqlite3` now sets :attr:`sqlite3.threadsafety` based on the default
+threading mode the underlying SQLite library has been compiled with. Patch by
+Erlend E. Aasland.

Modules/_sqlite/module.c

@@ -415,6 +415,28 @@ add_integer_constants(PyObject *module) {
  return 0;
 }
 
+/* Convert SQLite default threading mode (as set by the compile-time constant
+ * SQLITE_THREADSAFE) to the corresponding DB-API 2.0 (PEP 249) threadsafety
+ * level. */
+static int
+get_threadsafety(pysqlite_state *state)
+{
+ int mode = sqlite3_threadsafe();
+ switch (mode) {
+ case 0: // Single-thread mode; threads may not share the module.
+ return 0;
+ case 1: // Serialized mode; threads may share the module,
+ return 3; // connections, and cursors.
+ case 2: // Multi-thread mode; threads may share the module, but not
+ return 1; // connections.
+ default:
+ PyErr_Format(state->InterfaceError,
+ "Unable to interpret SQLite threadsafety mode. Got %d, "
+ "expected 0, 1, or 2", mode);
+ return -1;
+ }
+}
+
 static int
 module_traverse(PyObject *module, visitproc visit, void *arg)
 {
@@ -564,6 +586,14 @@ module_exec(PyObject *module)
  goto error;
  }
 
+ int threadsafety = get_threadsafety(state);
+ if (threadsafety < 0) {
+ goto error;
+ }
+ if (PyModule_AddIntConstant(module, "threadsafety", threadsafety) < 0) {
+ goto error;
+ }
+
  /* initialize microprotocols layer */
  if (pysqlite_microprotocols_init(module) < 0) {
  goto error;