IGNIETFERRO-1816 Update Python 3 from 3.9.12 to 3.10.4

ref:9f96be6d02ee8044fdd6f124b799b270c20ce641

1 files changed, 286 insertions, 193 deletions

diff --git a/contrib/tools/python3/src/Modules/_sqlite/cursor.c b/contrib/tools/python3/src/Modules/_sqlite/cursor.c
index e2635e18c73..85267cc9e77 100644
--- a/contrib/tools/python3/src/Modules/_sqlite/cursor.c
+++ b/contrib/tools/python3/src/Modules/_sqlite/cursor.c
@@ -24,20 +24,29 @@
 #include "cursor.h"
 #include "module.h"
 #include "util.h"
+#include "clinic/cursor.c.h"
 
-PyObject* pysqlite_cursor_iternext(pysqlite_Cursor* self);
+/*[clinic input]
+module _sqlite3
+class _sqlite3.Cursor "pysqlite_Cursor *" "pysqlite_CursorType"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b2072d8db95411d5]*/
 
 static const char errmsg_fetch_across_rollback[] = "Cursor needed to be reset because of commit/rollback and can no longer be fetched from.";
 
-static int pysqlite_cursor_init(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs)
-{
-    pysqlite_Connection* connection;
+/*[clinic input]
+_sqlite3.Cursor.__init__ as pysqlite_cursor_init
 
-    if (!PyArg_ParseTuple(args, "O!", &pysqlite_ConnectionType, &connection))
-    {
-        return -1;
-    }
+    connection: object(type='pysqlite_Connection *', subclass_of='pysqlite_ConnectionType')
+    /
+
+[clinic start generated code]*/
 
+static int
+pysqlite_cursor_init_impl(pysqlite_Cursor *self,
+                          pysqlite_Connection *connection)
+/*[clinic end generated code: output=ac59dce49a809ca8 input=a8a4f75ac90999b2]*/
+{
     Py_INCREF(connection);
     Py_XSETREF(self->connection, connection);
     Py_CLEAR(self->statement);
@@ -72,26 +81,49 @@ static int pysqlite_cursor_init(pysqlite_Cursor* self, PyObject* args, PyObject*
     return 0;
 }
 
-static void pysqlite_cursor_dealloc(pysqlite_Cursor* self)
+static int
+cursor_traverse(pysqlite_Cursor *self, visitproc visit, void *arg)
+{
+    Py_VISIT(Py_TYPE(self));
+    Py_VISIT(self->connection);
+    Py_VISIT(self->description);
+    Py_VISIT(self->row_cast_map);
+    Py_VISIT(self->lastrowid);
+    Py_VISIT(self->row_factory);
+    Py_VISIT(self->statement);
+    Py_VISIT(self->next_row);
+    return 0;
+}
+
+static int
+cursor_clear(pysqlite_Cursor *self)
 {
-    /* Reset the statement if the user has not closed the cursor */
+    Py_CLEAR(self->connection);
+    Py_CLEAR(self->description);
+    Py_CLEAR(self->row_cast_map);
+    Py_CLEAR(self->lastrowid);
+    Py_CLEAR(self->row_factory);
     if (self->statement) {
+        /* Reset the statement if the user has not closed the cursor */
         pysqlite_statement_reset(self->statement);
-        Py_DECREF(self->statement);
+        Py_CLEAR(self->statement);
     }
+    Py_CLEAR(self->next_row);
 
-    Py_XDECREF(self->connection);
-    Py_XDECREF(self->row_cast_map);
-    Py_XDECREF(self->description);
-    Py_XDECREF(self->lastrowid);
-    Py_XDECREF(self->row_factory);
-    Py_XDECREF(self->next_row);
+    return 0;
+}
 
+static void
+cursor_dealloc(pysqlite_Cursor *self)
+{
+    PyTypeObject *tp = Py_TYPE(self);
+    PyObject_GC_UnTrack(self);
     if (self->in_weakreflist != NULL) {
         PyObject_ClearWeakRefs((PyObject*)self);
     }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
+    tp->tp_clear((PyObject *)self);
+    tp->tp_free(self);
+    Py_DECREF(tp);
 }
 
 static PyObject *
@@ -123,7 +155,6 @@ pysqlite_build_row_cast_map(pysqlite_Cursor* self)
 {
     int i;
     const char* pos;
-    const char* colname;
     const char* decltype;
     PyObject* converter;
 
@@ -140,21 +171,24 @@ pysqlite_build_row_cast_map(pysqlite_Cursor* self)
         converter = NULL;
 
         if (self->connection->detect_types & PARSE_COLNAMES) {
-            colname = sqlite3_column_name(self->statement->st, i);
-            if (colname) {
-                const char *type_start = NULL;
-                for (pos = colname; *pos != 0; pos++) {
-                    if (*pos == '[') {
-                        type_start = pos + 1;
-                    }
-                    else if (*pos == ']' && type_start != NULL) {
-                        converter = _pysqlite_get_converter(type_start, pos - type_start);
-                        if (!converter && PyErr_Occurred()) {
-                            Py_CLEAR(self->row_cast_map);
-                            return -1;
-                        }
-                        break;
+            const char *colname = sqlite3_column_name(self->statement->st, i);
+            if (colname == NULL) {
+                PyErr_NoMemory();
+                Py_CLEAR(self->row_cast_map);
+                return -1;
+            }
+            const char *type_start = NULL;
+            for (pos = colname; *pos != 0; pos++) {
+                if (*pos == '[') {
+                    type_start = pos + 1;
+                }
+                else if (*pos == ']' && type_start != NULL) {
+                    converter = _pysqlite_get_converter(type_start, pos - type_start);
+                    if (!converter && PyErr_Occurred()) {
+                        Py_CLEAR(self->row_cast_map);
+                        return -1;
                     }
+                    break;
                 }
             }
         }
@@ -198,10 +232,6 @@ _pysqlite_build_column_name(pysqlite_Cursor *self, const char *colname)
     const char* pos;
     Py_ssize_t len;
 
-    if (!colname) {
-        Py_RETURN_NONE;
-    }
-
     if (self->connection->detect_types & PARSE_COLNAMES) {
         for (pos = colname; *pos; pos++) {
             if (*pos == '[') {
@@ -230,12 +260,10 @@ _pysqlite_fetch_one_row(pysqlite_Cursor* self)
 {
     int i, numcols;
     PyObject* row;
-    PyObject* item = NULL;
     int coltype;
     PyObject* converter;
     PyObject* converted;
     Py_ssize_t nbytes;
-    const char* val_str;
     char buf[200];
     const char* colname;
     PyObject* error_msg;
@@ -253,6 +281,7 @@ _pysqlite_fetch_one_row(pysqlite_Cursor* self)
     if (!row)
         return NULL;
 
+    sqlite3 *db = self->connection->db;
     for (i = 0; i < numcols; i++) {
         if (self->connection->detect_types
                 && self->row_cast_map != NULL
@@ -264,16 +293,27 @@ _pysqlite_fetch_one_row(pysqlite_Cursor* self)
             converter = Py_None;
         }
 
+        /*
+         * Note, sqlite3_column_bytes() must come after sqlite3_column_blob()
+         * or sqlite3_column_text().
+         *
+         * See https://sqlite.org/c3ref/column_blob.html for details.
+         */
         if (converter != Py_None) {
-            nbytes = sqlite3_column_bytes(self->statement->st, i);
-            val_str = (const char*)sqlite3_column_blob(self->statement->st, i);
-            if (!val_str) {
-                Py_INCREF(Py_None);
-                converted = Py_None;
-            } else {
-                item = PyBytes_FromStringAndSize(val_str, nbytes);
-                if (!item)
+            const void *blob = sqlite3_column_blob(self->statement->st, i);
+            if (blob == NULL) {
+                if (sqlite3_errcode(db) == SQLITE_NOMEM) {
+                    PyErr_NoMemory();
+                    goto error;
+                }
+                converted = Py_NewRef(Py_None);
+            }
+            else {
+                nbytes = sqlite3_column_bytes(self->statement->st, i);
+                PyObject *item = PyBytes_FromStringAndSize(blob, nbytes);
+                if (item == NULL) {
                     goto error;
+                }
                 converted = PyObject_CallOneArg(converter, item);
                 Py_DECREF(item);
             }
@@ -282,25 +322,30 @@ _pysqlite_fetch_one_row(pysqlite_Cursor* self)
             coltype = sqlite3_column_type(self->statement->st, i);
             Py_END_ALLOW_THREADS
             if (coltype == SQLITE_NULL) {
-                Py_INCREF(Py_None);
-                converted = Py_None;
+                converted = Py_NewRef(Py_None);
             } else if (coltype == SQLITE_INTEGER) {
                 converted = PyLong_FromLongLong(sqlite3_column_int64(self->statement->st, i));
             } else if (coltype == SQLITE_FLOAT) {
                 converted = PyFloat_FromDouble(sqlite3_column_double(self->statement->st, i));
             } else if (coltype == SQLITE_TEXT) {
-                val_str = (const char*)sqlite3_column_text(self->statement->st, i);
+                const char *text = (const char*)sqlite3_column_text(self->statement->st, i);
+                if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
+                    PyErr_NoMemory();
+                    goto error;
+                }
+
                 nbytes = sqlite3_column_bytes(self->statement->st, i);
                 if (self->connection->text_factory == (PyObject*)&PyUnicode_Type) {
-                    converted = PyUnicode_FromStringAndSize(val_str, nbytes);
+                    converted = PyUnicode_FromStringAndSize(text, nbytes);
                     if (!converted && PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
                         PyErr_Clear();
                         colname = sqlite3_column_name(self->statement->st, i);
-                        if (!colname) {
-                            colname = "<unknown column name>";
+                        if (colname == NULL) {
+                            PyErr_NoMemory();
+                            goto error;
                         }
                         PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'",
-                                     colname , val_str);
+                                     colname , text);
                         error_msg = PyUnicode_Decode(buf, strlen(buf), "ascii", "replace");
                         if (!error_msg) {
                             PyErr_SetString(pysqlite_OperationalError, "Could not decode to UTF-8");
@@ -310,24 +355,29 @@ _pysqlite_fetch_one_row(pysqlite_Cursor* self)
                         }
                     }
                 } else if (self->connection->text_factory == (PyObject*)&PyBytes_Type) {
-                    converted = PyBytes_FromStringAndSize(val_str, nbytes);
+                    converted = PyBytes_FromStringAndSize(text, nbytes);
                 } else if (self->connection->text_factory == (PyObject*)&PyByteArray_Type) {
-                    converted = PyByteArray_FromStringAndSize(val_str, nbytes);
+                    converted = PyByteArray_FromStringAndSize(text, nbytes);
                 } else {
-                    converted = PyObject_CallFunction(self->connection->text_factory, "y#", val_str, nbytes);
+                    converted = PyObject_CallFunction(self->connection->text_factory, "y#", text, nbytes);
                 }
             } else {
                 /* coltype == SQLITE_BLOB */
+                const void *blob = sqlite3_column_blob(self->statement->st, i);
+                if (blob == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
+                    PyErr_NoMemory();
+                    goto error;
+                }
+
                 nbytes = sqlite3_column_bytes(self->statement->st, i);
-                converted = PyBytes_FromStringAndSize(
-                    sqlite3_column_blob(self->statement->st, i), nbytes);
+                converted = PyBytes_FromStringAndSize(blob, nbytes);
             }
         }
 
         if (!converted) {
             goto error;
         }
-        PyTuple_SetItem(row, i, converted);
+        PyTuple_SET_ITEM(row, i, converted);
     }
 
     if (PyErr_Occurred())
@@ -366,9 +416,8 @@ static int check_cursor(pysqlite_Cursor* cur)
 }
 
 static PyObject *
-_pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
+_pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* operation, PyObject* second_argument)
 {
-    PyObject* operation;
     PyObject* parameters_list = NULL;
     PyObject* parameters_iter = NULL;
     PyObject* parameters = NULL;
@@ -377,9 +426,7 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
     PyObject* func_args;
     PyObject* result;
     int numcols;
-    PyObject* descriptor;
     PyObject* column_name;
-    PyObject* second_argument = NULL;
     sqlite_int64 lastrowid;
 
     if (!check_cursor(self)) {
@@ -392,15 +439,9 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
     Py_CLEAR(self->next_row);
 
     if (multiple) {
-        /* executemany() */
-        if (!PyArg_ParseTuple(args, "UO", &operation, &second_argument)) {
-            goto error;
-        }
-
         if (PyIter_Check(second_argument)) {
             /* iterator */
-            Py_INCREF(second_argument);
-            parameters_iter = second_argument;
+            parameters_iter = Py_NewRef(second_argument);
         } else {
             /* sequence */
             parameters_iter = PyObject_GetIter(second_argument);
@@ -409,11 +450,6 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
             }
         }
     } else {
-        /* execute() */
-        if (!PyArg_ParseTuple(args, "U|O", &operation, &second_argument)) {
-            goto error;
-        }
-
         parameters_list = PyList_New(0);
         if (!parameters_list) {
             goto error;
@@ -453,8 +489,7 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
     if (!func_args) {
         goto error;
     }
-    Py_INCREF(operation);
-    if (PyTuple_SetItem(func_args, 0, operation) != 0) {
+    if (PyTuple_SetItem(func_args, 0, Py_NewRef(operation)) != 0) {
         goto error;
     }
 
@@ -472,13 +507,8 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
 
     if (self->statement->in_use) {
         Py_SETREF(self->statement,
-                  PyObject_New(pysqlite_Statement, &pysqlite_StatementType));
-        if (!self->statement) {
-            goto error;
-        }
-        rc = pysqlite_statement_create(self->statement, self->connection, operation);
-        if (rc != SQLITE_OK) {
-            Py_CLEAR(self->statement);
+                  pysqlite_statement_create(self->connection, operation));
+        if (self->statement == NULL) {
             goto error;
         }
     }
@@ -541,24 +571,24 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args)
                 goto error;
             }
             for (i = 0; i < numcols; i++) {
-                descriptor = PyTuple_New(7);
-                if (!descriptor) {
+                const char *colname;
+                colname = sqlite3_column_name(self->statement->st, i);
+                if (colname == NULL) {
+                    PyErr_NoMemory();
                     goto error;
                 }
-                column_name = _pysqlite_build_column_name(self,
-                                sqlite3_column_name(self->statement->st, i));
-                if (!column_name) {
-                    Py_DECREF(descriptor);
+                column_name = _pysqlite_build_column_name(self, colname);
+                if (column_name == NULL) {
                     goto error;
                 }
-                PyTuple_SetItem(descriptor, 0, column_name);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 1, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 2, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 3, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 4, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 5, Py_None);
-                Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 6, Py_None);
-                PyTuple_SetItem(self->description, i, descriptor);
+                PyObject *descriptor = PyTuple_Pack(7, column_name,
+                                                    Py_None, Py_None, Py_None,
+                                                    Py_None, Py_None, Py_None);
+                Py_DECREF(column_name);
+                if (descriptor == NULL) {
+                    goto error;
+                }
+                PyTuple_SET_ITEM(self->description, i, descriptor);
             }
         }
 
@@ -609,34 +639,65 @@ error:
         self->rowcount = -1L;
         return NULL;
     } else {
-        Py_INCREF(self);
-        return (PyObject*)self;
+        return Py_NewRef((PyObject *)self);
     }
 }
 
-PyObject* pysqlite_cursor_execute(pysqlite_Cursor* self, PyObject* args)
+/*[clinic input]
+_sqlite3.Cursor.execute as pysqlite_cursor_execute
+
+    sql: unicode
+    parameters: object(c_default = 'NULL') = ()
+    /
+
+Executes an SQL statement.
+[clinic start generated code]*/
+
+static PyObject *
+pysqlite_cursor_execute_impl(pysqlite_Cursor *self, PyObject *sql,
+                             PyObject *parameters)
+/*[clinic end generated code: output=d81b4655c7c0bbad input=a8e0200a11627f94]*/
 {
-    return _pysqlite_query_execute(self, 0, args);
+    return _pysqlite_query_execute(self, 0, sql, parameters);
 }
 
-PyObject* pysqlite_cursor_executemany(pysqlite_Cursor* self, PyObject* args)
+/*[clinic input]
+_sqlite3.Cursor.executemany as pysqlite_cursor_executemany
+
+    sql: unicode
+    seq_of_parameters: object
+    /
+
+Repeatedly executes an SQL statement.
+[clinic start generated code]*/
+
+static PyObject *
+pysqlite_cursor_executemany_impl(pysqlite_Cursor *self, PyObject *sql,
+                                 PyObject *seq_of_parameters)
+/*[clinic end generated code: output=2c65a3c4733fb5d8 input=0d0a52e5eb7ccd35]*/
 {
-    return _pysqlite_query_execute(self, 1, args);
+    return _pysqlite_query_execute(self, 1, sql, seq_of_parameters);
 }
 
+/*[clinic input]
+_sqlite3.Cursor.executescript as pysqlite_cursor_executescript
+
+    sql_script as script_obj: object
+    /
+
+Executes multiple SQL statements at once.
+[clinic start generated code]*/
+
 static PyObject *
-pysqlite_cursor_executescript(pysqlite_Cursor* self, PyObject* args)
+pysqlite_cursor_executescript(pysqlite_Cursor *self, PyObject *script_obj)
+/*[clinic end generated code: output=115a8132b0f200fe input=75270e5bcdb4d6aa]*/
 {
-    PyObject* script_obj;
+    _Py_IDENTIFIER(commit);
     const char* script_cstr;
     sqlite3_stmt* statement;
     int rc;
     PyObject* result;
 
-    if (!PyArg_ParseTuple(args, "O", &script_obj)) {
-        return NULL;
-    }
-
     if (!check_cursor(self)) {
         return NULL;
     }
@@ -654,7 +715,7 @@ pysqlite_cursor_executescript(pysqlite_Cursor* self, PyObject* args)
     }
 
     /* commit first */
-    result = pysqlite_connection_commit(self->connection, NULL);
+    result = _PyObject_CallMethodIdNoArgs((PyObject *)self->connection, &PyId_commit);
     if (!result) {
         goto error;
     }
@@ -674,14 +735,13 @@ pysqlite_cursor_executescript(pysqlite_Cursor* self, PyObject* args)
         }
 
         /* execute statement, and ignore results of SELECT statements */
-        rc = SQLITE_ROW;
-        while (rc == SQLITE_ROW) {
+        do {
             rc = pysqlite_step(statement, self->connection);
             if (PyErr_Occurred()) {
                 (void)sqlite3_finalize(statement);
                 goto error;
             }
-        }
+        } while (rc == SQLITE_ROW);
 
         if (rc != SQLITE_DONE) {
             (void)sqlite3_finalize(statement);
@@ -704,12 +764,12 @@ error:
     if (PyErr_Occurred()) {
         return NULL;
     } else {
-        Py_INCREF(self);
-        return (PyObject*)self;
+        return Py_NewRef((PyObject *)self);
     }
 }
 
-PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self)
+static PyObject *
+pysqlite_cursor_iternext(pysqlite_Cursor *self)
 {
     PyObject* next_row_tuple;
     PyObject* next_row;
@@ -773,7 +833,15 @@ PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self)
     return next_row;
 }
 
-PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args)
+/*[clinic input]
+_sqlite3.Cursor.fetchone as pysqlite_cursor_fetchone
+
+Fetches one row from the resultset.
+[clinic start generated code]*/
+
+static PyObject *
+pysqlite_cursor_fetchone_impl(pysqlite_Cursor *self)
+/*[clinic end generated code: output=4bd2eabf5baaddb0 input=e78294ec5980fdba]*/
 {
     PyObject* row;
 
@@ -785,19 +853,23 @@ PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args)
     return row;
 }
 
-PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs)
-{
-    static char *kwlist[] = {"size", NULL};
+/*[clinic input]
+_sqlite3.Cursor.fetchmany as pysqlite_cursor_fetchmany
+
+    size as maxrows: int(c_default='self->arraysize') = 1
+        The default value is set by the Cursor.arraysize attribute.
+
+Fetches several rows from the resultset.
+[clinic start generated code]*/
 
+static PyObject *
+pysqlite_cursor_fetchmany_impl(pysqlite_Cursor *self, int maxrows)
+/*[clinic end generated code: output=a8ef31fea64d0906 input=c26e6ca3f34debd0]*/
+{
     PyObject* row;
     PyObject* list;
-    int maxrows = self->arraysize;
     int counter = 0;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:fetchmany", kwlist, &maxrows)) {
-        return NULL;
-    }
-
     list = PyList_New(0);
     if (!list) {
         return NULL;
@@ -823,7 +895,15 @@ PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args, PyObj
     }
 }
 
-PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args)
+/*[clinic input]
+_sqlite3.Cursor.fetchall as pysqlite_cursor_fetchall
+
+Fetches all rows from the resultset.
+[clinic start generated code]*/
+
+static PyObject *
+pysqlite_cursor_fetchall_impl(pysqlite_Cursor *self)
+/*[clinic end generated code: output=d5da12aca2da4b27 input=f5d401086a8df25a]*/
 {
     PyObject* row;
     PyObject* list;
@@ -849,13 +929,49 @@ PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args)
     }
 }
 
-PyObject* pysqlite_noop(pysqlite_Connection* self, PyObject* args)
+/*[clinic input]
+_sqlite3.Cursor.setinputsizes as pysqlite_cursor_setinputsizes
+
+    sizes: object
+    /
+
+Required by DB-API. Does nothing in sqlite3.
+[clinic start generated code]*/
+
+static PyObject *
+pysqlite_cursor_setinputsizes(pysqlite_Cursor *self, PyObject *sizes)
+/*[clinic end generated code: output=893c817afe9d08ad input=de7950a3aec79bdf]*/
+{
+    Py_RETURN_NONE;
+}
+
+/*[clinic input]
+_sqlite3.Cursor.setoutputsize as pysqlite_cursor_setoutputsize
+
+    size: object
+    column: object = None
+    /
+
+Required by DB-API. Does nothing in sqlite3.
+[clinic start generated code]*/
+
+static PyObject *
+pysqlite_cursor_setoutputsize_impl(pysqlite_Cursor *self, PyObject *size,
+                                   PyObject *column)
+/*[clinic end generated code: output=018d7e9129d45efe input=607a6bece8bbb273]*/
 {
-    /* don't care, return None */
     Py_RETURN_NONE;
 }
 
-PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args)
+/*[clinic input]
+_sqlite3.Cursor.close as pysqlite_cursor_close
+
+Closes the cursor.
+[clinic start generated code]*/
+
+static PyObject *
+pysqlite_cursor_close_impl(pysqlite_Cursor *self)
+/*[clinic end generated code: output=b6055e4ec6fe63b6 input=08b36552dbb9a986]*/
 {
     if (!self->connection) {
         PyErr_SetString(pysqlite_ProgrammingError,
@@ -877,24 +993,15 @@ PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args)
 }
 
 static PyMethodDef cursor_methods[] = {
-    {"execute", (PyCFunction)pysqlite_cursor_execute, METH_VARARGS,
-        PyDoc_STR("Executes an SQL statement.")},
-    {"executemany", (PyCFunction)pysqlite_cursor_executemany, METH_VARARGS,
-        PyDoc_STR("Repeatedly executes an SQL statement.")},
-    {"executescript", (PyCFunction)pysqlite_cursor_executescript, METH_VARARGS,
-        PyDoc_STR("Executes multiple SQL statements at once.")},
-    {"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS,
-        PyDoc_STR("Fetches one row from the resultset.")},
-    {"fetchmany", (PyCFunction)(void(*)(void))pysqlite_cursor_fetchmany, METH_VARARGS|METH_KEYWORDS,
-        PyDoc_STR("Fetches several rows from the resultset.")},
-    {"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS,
-        PyDoc_STR("Fetches all rows from the resultset.")},
-    {"close", (PyCFunction)pysqlite_cursor_close, METH_NOARGS,
-        PyDoc_STR("Closes the cursor.")},
-    {"setinputsizes", (PyCFunction)pysqlite_noop, METH_VARARGS,
-        PyDoc_STR("Required by DB-API. Does nothing in sqlite3.")},
-    {"setoutputsize", (PyCFunction)pysqlite_noop, METH_VARARGS,
-        PyDoc_STR("Required by DB-API. Does nothing in sqlite3.")},
+    PYSQLITE_CURSOR_CLOSE_METHODDEF
+    PYSQLITE_CURSOR_EXECUTEMANY_METHODDEF
+    PYSQLITE_CURSOR_EXECUTESCRIPT_METHODDEF
+    PYSQLITE_CURSOR_EXECUTE_METHODDEF
+    PYSQLITE_CURSOR_FETCHALL_METHODDEF
+    PYSQLITE_CURSOR_FETCHMANY_METHODDEF
+    PYSQLITE_CURSOR_FETCHONE_METHODDEF
+    PYSQLITE_CURSOR_SETINPUTSIZES_METHODDEF
+    PYSQLITE_CURSOR_SETOUTPUTSIZE_METHODDEF
     {NULL, NULL}
 };
 
@@ -906,56 +1013,42 @@ static struct PyMemberDef cursor_members[] =
     {"lastrowid", T_OBJECT, offsetof(pysqlite_Cursor, lastrowid), READONLY},
     {"rowcount", T_LONG, offsetof(pysqlite_Cursor, rowcount), READONLY},
     {"row_factory", T_OBJECT, offsetof(pysqlite_Cursor, row_factory), 0},
+    {"__weaklistoffset__", T_PYSSIZET, offsetof(pysqlite_Cursor, in_weakreflist), READONLY},
     {NULL}
 };
 
 static const char cursor_doc[] =
 PyDoc_STR("SQLite database cursor class.");
 
-PyTypeObject pysqlite_CursorType = {
-        PyVarObject_HEAD_INIT(NULL, 0)
-        MODULE_NAME ".Cursor",                          /* tp_name */
-        sizeof(pysqlite_Cursor),                        /* tp_basicsize */
-        0,                                              /* tp_itemsize */
-        (destructor)pysqlite_cursor_dealloc,            /* tp_dealloc */
-        0,                                              /* tp_vectorcall_offset */
-        0,                                              /* tp_getattr */
-        0,                                              /* tp_setattr */
-        0,                                              /* tp_as_async */
-        0,                                              /* tp_repr */
-        0,                                              /* tp_as_number */
-        0,                                              /* tp_as_sequence */
-        0,                                              /* tp_as_mapping */
-        0,                                              /* tp_hash */
-        0,                                              /* tp_call */
-        0,                                              /* tp_str */
-        0,                                              /* tp_getattro */
-        0,                                              /* tp_setattro */
-        0,                                              /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
-        cursor_doc,                                     /* tp_doc */
-        0,                                              /* tp_traverse */
-        0,                                              /* tp_clear */
-        0,                                              /* tp_richcompare */
-        offsetof(pysqlite_Cursor, in_weakreflist),      /* tp_weaklistoffset */
-        PyObject_SelfIter,                              /* tp_iter */
-        (iternextfunc)pysqlite_cursor_iternext,         /* tp_iternext */
-        cursor_methods,                                 /* tp_methods */
-        cursor_members,                                 /* tp_members */
-        0,                                              /* tp_getset */
-        0,                                              /* tp_base */
-        0,                                              /* tp_dict */
-        0,                                              /* tp_descr_get */
-        0,                                              /* tp_descr_set */
-        0,                                              /* tp_dictoffset */
-        (initproc)pysqlite_cursor_init,                 /* tp_init */
-        0,                                              /* tp_alloc */
-        0,                                              /* tp_new */
-        0                                               /* tp_free */
+static PyType_Slot cursor_slots[] = {
+    {Py_tp_dealloc, cursor_dealloc},
+    {Py_tp_doc, (void *)cursor_doc},
+    {Py_tp_iter, PyObject_SelfIter},
+    {Py_tp_iternext, pysqlite_cursor_iternext},
+    {Py_tp_methods, cursor_methods},
+    {Py_tp_members, cursor_members},
+    {Py_tp_init, pysqlite_cursor_init},
+    {Py_tp_traverse, cursor_traverse},
+    {Py_tp_clear, cursor_clear},
+    {0, NULL},
 };
 
-extern int pysqlite_cursor_setup_types(void)
+static PyType_Spec cursor_spec = {
+    .name = MODULE_NAME ".Cursor",
+    .basicsize = sizeof(pysqlite_Cursor),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
+              Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
+    .slots = cursor_slots,
+};
+
+PyTypeObject *pysqlite_CursorType = NULL;
+
+int
+pysqlite_cursor_setup_types(PyObject *module)
 {
-    pysqlite_CursorType.tp_new = PyType_GenericNew;
-    return PyType_Ready(&pysqlite_CursorType);
+    pysqlite_CursorType = (PyTypeObject *)PyType_FromModuleAndSpec(module, &cursor_spec, NULL);
+    if (pysqlite_CursorType == NULL) {
+        return -1;
+    }
+    return 0;
 }