From bf64d9064ab641b1ef9a0c4bda097ebf1204faf4 Mon Sep 17 00:00:00 2001 From: Erlend Egeberg Aasland Date: Sun, 27 Dec 2020 12:05:33 +0100 Subject: [PATCH] bpo-1635741: sqlite3 uses Py_NewRef/Py_XNewRef (GH-23170) --- Modules/_sqlite/cache.c | 13 ++++--------- Modules/_sqlite/connection.c | 29 +++++++++-------------------- Modules/_sqlite/cursor.c | 30 ++++++++++++------------------ Modules/_sqlite/microprotocols.c | 3 +-- Modules/_sqlite/module.c | 13 +++---------- Modules/_sqlite/row.c | 24 +++++++++--------------- Modules/_sqlite/statement.c | 15 +++++++-------- 7 files changed, 45 insertions(+), 82 deletions(-) diff --git a/Modules/_sqlite/cache.c b/Modules/_sqlite/cache.c index 8cedd07b459..078a484b86c 100644 --- a/Modules/_sqlite/cache.c +++ b/Modules/_sqlite/cache.c @@ -34,11 +34,8 @@ pysqlite_Node* pysqlite_new_node(PyObject* key, PyObject* data) return NULL; } - Py_INCREF(key); - node->key = key; - - Py_INCREF(data); - node->data = data; + node->key = Py_NewRef(key); + node->data = Py_NewRef(data); node->prev = NULL; node->next = NULL; @@ -81,8 +78,7 @@ int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs) return -1; } - Py_INCREF(factory); - self->factory = factory; + self->factory = Py_NewRef(factory); self->decref_factory = 1; @@ -218,8 +214,7 @@ PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* key) self->last = node; } - Py_INCREF(node->data); - return node->data; + return Py_NewRef(node->data); } PyObject* pysqlite_cache_display(pysqlite_Cache* self, PyObject* args) diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c index 7f13f96cac4..46717acf7c7 100644 --- a/Modules/_sqlite/connection.c +++ b/Modules/_sqlite/connection.c @@ -575,8 +575,7 @@ PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_ /* TODO: have a way to show errors here */ if (!cur_py_value) { PyErr_Clear(); - Py_INCREF(Py_None); - cur_py_value = Py_None; + cur_py_value = Py_NewRef(Py_None); } break; case SQLITE_BLOB: @@ -586,8 +585,7 @@ PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_ break; case SQLITE_NULL: default: - Py_INCREF(Py_None); - cur_py_value = Py_None; + cur_py_value = Py_NewRef(Py_None); } if (!cur_py_value) { @@ -853,12 +851,11 @@ pysqlite_connection_create_function_impl(pysqlite_Connection *self, flags |= SQLITE_DETERMINISTIC; #endif } - Py_INCREF(func); rc = sqlite3_create_function_v2(self->db, name, narg, flags, - (void*)func, + (void*)Py_NewRef(func), _pysqlite_func_callback, NULL, NULL, @@ -899,7 +896,7 @@ pysqlite_connection_create_aggregate_impl(pysqlite_Connection *self, name, n_arg, SQLITE_UTF8, - (void*)aggregate_class, + (void*)Py_NewRef(aggregate_class), 0, &_pysqlite_step_callback, &_pysqlite_final_callback, @@ -1212,8 +1209,7 @@ int pysqlite_check_thread(pysqlite_Connection* self) static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused) { - Py_INCREF(self->isolation_level); - return self->isolation_level; + return Py_NewRef(self->isolation_level); } static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused) @@ -1526,8 +1522,7 @@ pysqlite_connection_interrupt_impl(pysqlite_Connection *self) sqlite3_interrupt(self->db); - Py_INCREF(Py_None); - retval = Py_None; + retval = Py_NewRef(Py_None); finally: return retval; @@ -1746,7 +1741,6 @@ pysqlite_connection_create_collation_impl(pysqlite_Connection *self, /*[clinic end generated code: output=0f63b8995565ae22 input=5c3898813a776cf2]*/ { PyObject* uppercase_name = 0; - PyObject* retval; Py_ssize_t i, len; _Py_IDENTIFIER(upper); const char *uppercase_name_str; @@ -1814,13 +1808,9 @@ finally: Py_XDECREF(uppercase_name); if (PyErr_Occurred()) { - retval = NULL; - } else { - Py_INCREF(Py_None); - retval = Py_None; + return NULL; } - - return retval; + return Py_NewRef(Py_None); } /*[clinic input] @@ -1835,8 +1825,7 @@ static PyObject * pysqlite_connection_enter_impl(pysqlite_Connection *self) /*[clinic end generated code: output=457b09726d3e9dcd input=127d7a4f17e86d8f]*/ { - Py_INCREF(self); - return (PyObject*)self; + return Py_NewRef((PyObject *)self); } /*[clinic input] diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c index 2651e154df5..13385f6d500 100644 --- a/Modules/_sqlite/cursor.c +++ b/Modules/_sqlite/cursor.c @@ -271,8 +271,7 @@ _pysqlite_fetch_one_row(pysqlite_Cursor* self) 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; + converted = Py_NewRef(Py_None); } else { item = PyBytes_FromStringAndSize(val_str, nbytes); if (!item) @@ -285,8 +284,7 @@ _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) { @@ -402,8 +400,7 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args) 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); @@ -456,8 +453,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; } @@ -555,12 +551,12 @@ _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args) 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(descriptor, 1, Py_NewRef(Py_None)); + PyTuple_SetItem(descriptor, 2, Py_NewRef(Py_None)); + PyTuple_SetItem(descriptor, 3, Py_NewRef(Py_None)); + PyTuple_SetItem(descriptor, 4, Py_NewRef(Py_None)); + PyTuple_SetItem(descriptor, 5, Py_NewRef(Py_None)); + PyTuple_SetItem(descriptor, 6, Py_NewRef(Py_None)); PyTuple_SetItem(self->description, i, descriptor); } } @@ -610,8 +606,7 @@ error: self->rowcount = -1L; return NULL; } else { - Py_INCREF(self); - return (PyObject*)self; + return Py_NewRef((PyObject *)self); } } @@ -706,8 +701,7 @@ error: if (PyErr_Occurred()) { return NULL; } else { - Py_INCREF(self); - return (PyObject*)self; + return Py_NewRef((PyObject *)self); } } diff --git a/Modules/_sqlite/microprotocols.c b/Modules/_sqlite/microprotocols.c index 41f086791ea..e219a7239f8 100644 --- a/Modules/_sqlite/microprotocols.c +++ b/Modules/_sqlite/microprotocols.c @@ -140,8 +140,7 @@ pysqlite_microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt) } if (alt) { - Py_INCREF(alt); - return alt; + return Py_NewRef(alt); } /* else set the right exception and return NULL */ PyErr_SetString(pysqlite_ProgrammingError, "can't adapt"); diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c index 372f3dda4cb..cd2eb576c7b 100644 --- a/Modules/_sqlite/module.c +++ b/Modules/_sqlite/module.c @@ -120,17 +120,11 @@ static PyObject * pysqlite_complete_statement_impl(PyObject *module, const char *statement) /*[clinic end generated code: output=e55f1ff1952df558 input=f6b24996b31c5c33]*/ { - PyObject* result; - if (sqlite3_complete(statement)) { - result = Py_True; + return Py_NewRef(Py_True); } else { - result = Py_False; + return Py_NewRef(Py_False); } - - Py_INCREF(result); - - return result; } /*[clinic input] @@ -219,8 +213,7 @@ pysqlite_register_converter_impl(PyObject *module, PyObject *orig_name, goto error; } - Py_INCREF(Py_None); - retval = Py_None; + retval = Py_NewRef(Py_None); error: Py_XDECREF(name); return retval; diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c index 76b6f04f0cc..9086c19af73 100644 --- a/Modules/_sqlite/row.c +++ b/Modules/_sqlite/row.c @@ -63,20 +63,16 @@ pysqlite_row_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) if (self == NULL) return NULL; - Py_INCREF(data); - self->data = data; - - Py_INCREF(cursor->description); - self->description = cursor->description; + self->data = Py_NewRef(data); + self->description = Py_NewRef(cursor->description); return (PyObject *) self; } PyObject* pysqlite_row_item(pysqlite_Row* self, Py_ssize_t idx) { - PyObject* item = PyTuple_GetItem(self->data, idx); - Py_XINCREF(item); - return item; + PyObject *item = PyTuple_GetItem(self->data, idx); + return Py_XNewRef(item); } static int @@ -111,7 +107,6 @@ PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx) { Py_ssize_t _idx; Py_ssize_t nitems, i; - PyObject* item; if (PyLong_Check(idx)) { _idx = PyNumber_AsSsize_t(idx, PyExc_IndexError); @@ -119,9 +114,9 @@ PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx) return NULL; if (_idx < 0) _idx += PyTuple_GET_SIZE(self->data); - item = PyTuple_GetItem(self->data, _idx); - Py_XINCREF(item); - return item; + + PyObject *item = PyTuple_GetItem(self->data, _idx); + return Py_XNewRef(item); } else if (PyUnicode_Check(idx)) { nitems = PyTuple_Size(self->description); @@ -135,9 +130,8 @@ PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx) } if (eq) { /* found item */ - item = PyTuple_GetItem(self->data, i); - Py_INCREF(item); - return item; + PyObject *item = PyTuple_GetItem(self->data, i); + return Py_XNewRef(item); } } diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c index 4682d286c58..b62de58109e 100644 --- a/Modules/_sqlite/statement.c +++ b/Modules/_sqlite/statement.c @@ -72,8 +72,7 @@ int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* con } self->in_weakreflist = NULL; - Py_INCREF(sql); - self->sql = sql; + self->sql = Py_NewRef(sql); /* Determine if the statement is a DML statement. SELECT is the only exception. See #9924. */ @@ -240,11 +239,11 @@ void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* para } for (i = 0; i < num_params; i++) { if (PyTuple_CheckExact(parameters)) { - current_param = PyTuple_GET_ITEM(parameters, i); - Py_INCREF(current_param); + PyObject *item = PyTuple_GET_ITEM(parameters, i); + current_param = Py_NewRef(item); } else if (PyList_CheckExact(parameters)) { - current_param = PyList_GetItem(parameters, i); - Py_XINCREF(current_param); + PyObject *item = PyList_GetItem(parameters, i); + current_param = Py_XNewRef(item); } else { current_param = PySequence_GetItem(parameters, i); } @@ -290,8 +289,8 @@ void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* para return; } if (PyDict_CheckExact(parameters)) { - current_param = PyDict_GetItemWithError(parameters, binding_name_obj); - Py_XINCREF(current_param); + PyObject *item = PyDict_GetItemWithError(parameters, binding_name_obj); + current_param = Py_XNewRef(item); } else { current_param = PyObject_GetItem(parameters, binding_name_obj); }