Add sqlite3_setlk_timeout

Author: rogerbinns

apsw/tests/__main__.py

@@ -1426,6 +1426,16 @@ def testFormatSQLValue(self):
         self.assertRaises(TypeError, apsw.format_sql_value, apsw)
         self.assertRaises(TypeError, apsw.format_sql_value)
 
+    def testSetlkTimeout(self):
+        "sqlite3_setlk_timeout"
+        self.assertRaises(OverflowError, self.db.setlk_timeout, sys.maxsize * 64, apsw.SQLITE_SETLK_BLOCK_ON_CONNECT)
+        # it current gives range for values less than -1
+        self.assertRaises(apsw.RangeError, self.db.setlk_timeout, -2, apsw.SQLITE_SETLK_BLOCK_ON_CONNECT)
+
+        # no error is given for unknown flags so we don't test them
+        self.db.setlk_timeout(1000, apsw.SQLITE_SETLK_BLOCK_ON_CONNECT)
+
+
     def testVTableStuff(self):
         "Test new stuff added for Virtual tables"
 

doc/changes.rst

@@ -15,6 +15,10 @@ APSW changes by version
 
 Full support for the :doc:`session`
 
+Added :meth:`Connection.setlk_timeout`,
+:attr:`apsw.mapping_setlk_timeout_flags`, and enabled the timeout for
+amalgamation builds such as PyPI.
+
 Shell :ref:`open command <shell-cmd-open>` allows specifying flags to
 open a connection, and :ref:`connection command
 <shell-cmd-connection>` shows flags used for each open. (:issue:`557`)

src/apsw.c

@@ -81,6 +81,10 @@ API Reference
 #define SQLITE_MAX_MMAP_SIZE 0x1000000000000LL
 #endif
 
+#ifndef SQLITE_ENABLE_SETLK_TIMEOUT
+#define SQLITE_ENABLE_SETLK_TIMEOUT 1
+#endif
+
 #ifndef SQLITE_DEBUG
 #define SQLITE_API static
 #define SQLITE_EXTERN static

src/apsw.docstrings

@@ -2476,6 +2476,20 @@
 #define Connection_set_wal_hook_OLDNAME "setwalhook"
 #define Connection_set_wal_hook_OLDDOC Connection_set_wal_hook_USAGE "\n(Old less clear name setwalhook)"
 
+#define  Connection_setlk_timeout_DOC "Connection.setlk_timeout(ms: int, flags: int) -> None\n\n" \
+"Sets a VFS level timeout.\n" \
+"\n" \
+"Calls: `sqlite3_setlk_timeout <https://sqlite.org/c3ref/setlk_timeout.html>`__\n" 
+
+#define Connection_setlk_timeout_KWNAMES "ms", "flags"
+#define Connection_setlk_timeout_USAGE "Connection.setlk_timeout(ms: int, flags: int) -> None"
+
+#define Connection_setlk_timeout_CHECK do { \
+  assert(__builtin_types_compatible_p(typeof(ms), int)); \
+  assert(__builtin_types_compatible_p(typeof(flags), int)); \
+} while(0)
+
+
 #define  Connection_sqlite3_pointer_DOC "Connection.sqlite3_pointer() -> int\n\n" \
 "Returns the underlying `sqlite3 *\n" \
 "<https://sqlite.org/c3ref/sqlite3.html>`_ for the connection. This\n" \

src/connection.c

@@ -5545,6 +5545,35 @@ Connection_data_version(PyObject *self_, PyObject *const *fast_args, Py_ssize_t
   return PyErr_Occurred() ? NULL : PyLong_FromLong(data_version);
 }
 
+/** .. method:: setlk_timeout(ms: int, flags: int) -> None
+
+  Sets a VFS level timeout.
+
+  -* sqlite3_setlk_timeout
+
+*/
+static PyObject *
+Connection_setlk_timeout(PyObject *self_, PyObject *const *fast_args, Py_ssize_t fast_nargs, PyObject *fast_kwnames)
+{
+  Connection *self = (Connection *)self_;
+  CHECK_CLOSED(self, NULL);
+
+  int ms, flags;
+  {
+    Connection_setlk_timeout_CHECK;
+    ARG_PROLOG(2, Connection_setlk_timeout_KWNAMES);
+    ARG_MANDATORY ARG_int(ms);
+    ARG_MANDATORY ARG_int(flags);
+    ARG_EPILOG(NULL, Connection_setlk_timeout_USAGE, );
+  }
+
+  int res = sqlite3_setlk_timeout(self->db, ms, flags);
+  SET_EXC(res, NULL);
+  if(PyErr_Occurred())
+    return NULL;
+  Py_RETURN_NONE;
+}
+
 /* done this way here to keep doc generation simple */
 #include "fts.c"
 
@@ -6014,6 +6043,7 @@ static PyMethodDef Connection_methods[] = {
   { "register_fts5_function", (PyCFunction)Connection_register_fts5_function, METH_FASTCALL | METH_KEYWORDS,
     Connection_register_fts5_function_DOC },
   { "data_version", (PyCFunction)Connection_data_version, METH_FASTCALL | METH_KEYWORDS, Connection_data_version_DOC },
+  { "setlk_timeout", (PyCFunction)Connection_setlk_timeout, METH_FASTCALL | METH_KEYWORDS, Connection_setlk_timeout_DOC },
 #ifndef APSW_OMIT_OLD_NAMES
   { Connection_set_busy_timeout_OLDNAME, (PyCFunction)Connection_set_busy_timeout, METH_FASTCALL | METH_KEYWORDS,
     Connection_set_busy_timeout_OLDDOC },

src/constants.c

@@ -476,6 +476,22 @@ add_apsw_constants(PyObject *module)
         return -1;
     }
 
+    /* Flags for sqlite3_setlk_timeout() */
+    the_dict = Py_BuildValue(
+        "{siis}",
+        "SQLITE_SETLK_BLOCK_ON_CONNECT", SQLITE_SETLK_BLOCK_ON_CONNECT, SQLITE_SETLK_BLOCK_ON_CONNECT, "SQLITE_SETLK_BLOCK_ON_CONNECT");
+    if (!the_dict)
+    {
+        assert(PyErr_Occurred());
+        return -1;
+    }
+    if (PyModule_AddObject(module, "mapping_setlk_timeout_flags", the_dict))
+    {
+        assert(PyErr_Occurred());
+        Py_DECREF(the_dict);
+        return -1;
+    }
+
 #ifdef SQLITE_ENABLE_SESSION
     /* Flags for sqlite3changeset_apply_v2 */
     the_dict = Py_BuildValue(
@@ -705,8 +721,9 @@ add_apsw_constants(PyObject *module)
 
     /* Standard File Control Opcodes */
     the_dict = Py_BuildValue(
-        "{siissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiis}",
+        "{siissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiissiis}",
         "SQLITE_FCNTL_BEGIN_ATOMIC_WRITE", SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, "SQLITE_FCNTL_BEGIN_ATOMIC_WRITE",
+        "SQLITE_FCNTL_BLOCK_ON_CONNECT", SQLITE_FCNTL_BLOCK_ON_CONNECT, SQLITE_FCNTL_BLOCK_ON_CONNECT, "SQLITE_FCNTL_BLOCK_ON_CONNECT",
         "SQLITE_FCNTL_BUSYHANDLER", SQLITE_FCNTL_BUSYHANDLER, SQLITE_FCNTL_BUSYHANDLER, "SQLITE_FCNTL_BUSYHANDLER",
         "SQLITE_FCNTL_CHUNK_SIZE", SQLITE_FCNTL_CHUNK_SIZE, SQLITE_FCNTL_CHUNK_SIZE, "SQLITE_FCNTL_CHUNK_SIZE",
         "SQLITE_FCNTL_CKPT_DONE", SQLITE_FCNTL_CKPT_DONE, SQLITE_FCNTL_CKPT_DONE, "SQLITE_FCNTL_CKPT_DONE",
@@ -1088,6 +1105,7 @@ add_apsw_constants(PyObject *module)
         || PyModule_AddIntConstant(module, "SQLITE_ERROR_SNAPSHOT", SQLITE_ERROR_SNAPSHOT)
         || PyModule_AddIntConstant(module, "SQLITE_FAIL", SQLITE_FAIL)
         || PyModule_AddIntConstant(module, "SQLITE_FCNTL_BEGIN_ATOMIC_WRITE", SQLITE_FCNTL_BEGIN_ATOMIC_WRITE)
+        || PyModule_AddIntConstant(module, "SQLITE_FCNTL_BLOCK_ON_CONNECT", SQLITE_FCNTL_BLOCK_ON_CONNECT)
         || PyModule_AddIntConstant(module, "SQLITE_FCNTL_BUSYHANDLER", SQLITE_FCNTL_BUSYHANDLER)
         || PyModule_AddIntConstant(module, "SQLITE_FCNTL_CHUNK_SIZE", SQLITE_FCNTL_CHUNK_SIZE)
         || PyModule_AddIntConstant(module, "SQLITE_FCNTL_CKPT_DONE", SQLITE_FCNTL_CKPT_DONE)
@@ -1288,6 +1306,7 @@ add_apsw_constants(PyObject *module)
         || PyModule_AddIntConstant(module, "SQLITE_SCHEMA", SQLITE_SCHEMA)
         || PyModule_AddIntConstant(module, "SQLITE_SELECT", SQLITE_SELECT)
         || PyModule_AddIntConstant(module, "SQLITE_SELFORDER1", SQLITE_SELFORDER1)
+        || PyModule_AddIntConstant(module, "SQLITE_SETLK_BLOCK_ON_CONNECT", SQLITE_SETLK_BLOCK_ON_CONNECT)
         || PyModule_AddIntConstant(module, "SQLITE_SHM_EXCLUSIVE", SQLITE_SHM_EXCLUSIVE)
         || PyModule_AddIntConstant(module, "SQLITE_SHM_LOCK", SQLITE_SHM_LOCK)
         || PyModule_AddIntConstant(module, "SQLITE_SHM_SHARED", SQLITE_SHM_SHARED)

tools/genconstants.py

@@ -27,6 +27,7 @@
     "Flags For File Open Operations": "open_flags",
     "Flags for sqlite3_deserialize()": None,
     "Flags for sqlite3_serialize": None,
+    "Flags for sqlite3_setlk_timeout()": "setlk_timeout_flags",
     "Flags for the xAccess VFS method": "access",
     "Flags for the xShmLock VFS method": "xshmlock_flags",
     "Function Flags": "function_flags",