Updated the sqlite3 module to the external pysqlite 2.2.2 version.
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index 78aad37..64e43eb 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -56,6 +56,7 @@
self->begin_statement = NULL;
self->statement_cache = NULL;
+ self->statements = NULL;
Py_INCREF(Py_None);
self->row_factory = Py_None;
@@ -74,6 +75,9 @@
if (!isolation_level) {
isolation_level = PyString_FromString("");
+ if (!isolation_level) {
+ return -1;
+ }
} else {
Py_INCREF(isolation_level);
}
@@ -86,6 +90,12 @@
return -1;
}
+ self->statements = PyList_New(0);
+ if (!self->statements) {
+ return -1;
+ }
+ self->created_statements = 0;
+
/* By default, the Cache class INCREFs the factory in its initializer, and
* decrefs it in its deallocator method. Since this would create a circular
* reference here, we're breaking it by decrementing self, and telling the
@@ -126,6 +136,7 @@
return 0;
}
+/* Empty the entire statement cache of this connection */
void flush_statement_cache(Connection* self)
{
Node* node;
@@ -147,15 +158,16 @@
void reset_all_statements(Connection* self)
{
- Node* node;
- Statement* statement;
+ int i;
+ PyObject* weakref;
+ PyObject* statement;
- node = self->statement_cache->first;
-
- while (node) {
- statement = (Statement*)(node->data);
- (void)statement_reset(statement);
- node = node->next;
+ for (i = 0; i < PyList_Size(self->statements); i++) {
+ weakref = PyList_GetItem(self->statements, i);
+ statement = PyWeakref_GetObject(weakref);
+ if (statement != Py_None) {
+ (void)statement_reset((Statement*)statement);
+ }
}
}
@@ -178,6 +190,7 @@
Py_XDECREF(self->row_factory);
Py_XDECREF(self->text_factory);
Py_XDECREF(self->collations);
+ Py_XDECREF(self->statements);
self->ob_type->tp_free((PyObject*)self);
}
@@ -391,7 +404,7 @@
Py_ssize_t buflen;
PyObject* stringval;
- if (PyErr_Occurred()) {
+ if ((!py_val) || PyErr_Occurred()) {
/* Errors in callbacks are ignored, and we return NULL */
PyErr_Clear();
sqlite3_result_null(context);
@@ -399,21 +412,23 @@
sqlite3_result_null(context);
} else if (PyInt_Check(py_val)) {
longval = PyInt_AsLong(py_val);
- /* TODO: investigate what to do with range overflows - long vs. long long */
sqlite3_result_int64(context, (PY_LONG_LONG)longval);
} else if (PyFloat_Check(py_val)) {
sqlite3_result_double(context, PyFloat_AsDouble(py_val));
} else if (PyBuffer_Check(py_val)) {
if (PyObject_AsCharBuffer(py_val, &buffer, &buflen) != 0) {
PyErr_SetString(PyExc_ValueError, "could not convert BLOB to buffer");
+ } else {
+ sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT);
}
- sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT);
} else if (PyString_Check(py_val)) {
sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT);
} else if (PyUnicode_Check(py_val)) {
stringval = PyUnicode_AsUTF8String(py_val);
- sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT);
- Py_DECREF(stringval);
+ if (stringval) {
+ sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT);
+ Py_DECREF(stringval);
+ }
} else {
/* TODO: raise error */
}
@@ -450,6 +465,7 @@
cur_py_value = PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
/* TODO: have a way to show errors here */
if (!cur_py_value) {
+ PyErr_Clear();
Py_INCREF(Py_None);
cur_py_value = Py_None;
}
@@ -458,10 +474,12 @@
buflen = sqlite3_value_bytes(cur_value);
cur_py_value = PyBuffer_New(buflen);
if (!cur_py_value) {
- /* TODO: error */
+ break;
}
if (PyObject_AsWriteBuffer(cur_py_value, &raw_buffer, &buflen)) {
- /* TODO: error */
+ Py_DECREF(cur_py_value);
+ cur_py_value = NULL;
+ break;
}
memcpy(raw_buffer, sqlite3_value_blob(cur_value), buflen);
break;
@@ -470,6 +488,12 @@
Py_INCREF(Py_None);
cur_py_value = Py_None;
}
+
+ if (!cur_py_value) {
+ Py_DECREF(args);
+ return NULL;
+ }
+
PyTuple_SetItem(args, i, cur_py_value);
}
@@ -481,8 +505,7 @@
{
PyObject* args;
PyObject* py_func;
- PyObject* py_retval;
-
+ PyObject* py_retval = NULL;
PyGILState_STATE threadstate;
@@ -491,9 +514,10 @@
py_func = (PyObject*)sqlite3_user_data(context);
args = _build_py_params(context, argc, argv);
-
- py_retval = PyObject_CallObject(py_func, args);
- Py_DECREF(args);
+ if (args) {
+ py_retval = PyObject_CallObject(py_func, args);
+ Py_DECREF(args);
+ }
_set_result(context, py_retval);
Py_XDECREF(py_retval);
@@ -504,10 +528,10 @@
static void _step_callback(sqlite3_context *context, int argc, sqlite3_value** params)
{
PyObject* args;
- PyObject* function_result;
+ PyObject* function_result = NULL;
PyObject* aggregate_class;
PyObject** aggregate_instance;
- PyObject* stepmethod;
+ PyObject* stepmethod = NULL;
PyGILState_STATE threadstate;
@@ -520,44 +544,42 @@
if (*aggregate_instance == 0) {
*aggregate_instance = PyObject_CallFunction(aggregate_class, "");
- if (PyErr_Occurred())
- {
+ if (PyErr_Occurred()) {
PyErr_Clear();
*aggregate_instance = 0;
- PyGILState_Release(threadstate);
- return;
+ goto error;
}
}
stepmethod = PyObject_GetAttrString(*aggregate_instance, "step");
- if (!stepmethod)
- {
- PyGILState_Release(threadstate);
- return;
+ if (!stepmethod) {
+ goto error;
}
args = _build_py_params(context, argc, params);
+ if (!args) {
+ goto error;
+ }
function_result = PyObject_CallObject(stepmethod, args);
Py_DECREF(args);
- Py_DECREF(stepmethod);
- if (function_result == NULL) {
+ if (!function_result) {
PyErr_Clear();
- } else {
- Py_DECREF(function_result);
}
+error:
+ Py_XDECREF(stepmethod);
+ Py_XDECREF(function_result);
+
PyGILState_Release(threadstate);
}
void _final_callback(sqlite3_context* context)
{
- PyObject* args;
- PyObject* function_result;
+ PyObject* function_result = NULL;
PyObject** aggregate_instance;
PyObject* aggregate_class;
- PyObject* finalizemethod;
PyGILState_STATE threadstate;
@@ -570,35 +592,56 @@
/* this branch is executed if there was an exception in the aggregate's
* __init__ */
- PyGILState_Release(threadstate);
- return;
+ goto error;
}
- finalizemethod = PyObject_GetAttrString(*aggregate_instance, "finalize");
-
- if (!finalizemethod) {
- /*
- PyErr_SetString(ProgrammingError, "finalize method missing");
- goto error;
- */
+ function_result = PyObject_CallMethod(*aggregate_instance, "finalize", "");
+ if (!function_result) {
+ PyErr_Clear();
Py_INCREF(Py_None);
function_result = Py_None;
- } else {
- args = PyTuple_New(0);
- if (!args)
- return;
- function_result = PyObject_CallObject(finalizemethod, args);
- Py_DECREF(args);
- Py_DECREF(finalizemethod);
}
_set_result(context, function_result);
+
+error:
Py_XDECREF(*aggregate_instance);
Py_XDECREF(function_result);
PyGILState_Release(threadstate);
}
+void _drop_unused_statement_references(Connection* self)
+{
+ PyObject* new_list;
+ PyObject* weakref;
+ int i;
+
+ /* we only need to do this once in a while */
+ if (self->created_statements++ < 200) {
+ return;
+ }
+
+ self->created_statements = 0;
+
+ new_list = PyList_New(0);
+ if (!new_list) {
+ return;
+ }
+
+ for (i = 0; i < PyList_Size(self->statements); i++) {
+ weakref = PyList_GetItem(self->statements, i);
+ if (weakref != Py_None) {
+ if (PyList_Append(new_list, weakref) != 0) {
+ Py_DECREF(new_list);
+ return;
+ }
+ }
+ }
+
+ Py_DECREF(self->statements);
+ self->statements = new_list;
+}
PyObject* connection_create_function(Connection* self, PyObject* args, PyObject* kwargs)
{
@@ -617,10 +660,16 @@
rc = sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _func_callback, NULL, NULL);
- PyDict_SetItem(self->function_pinboard, func, Py_None);
+ if (rc != SQLITE_OK) {
+ /* Workaround for SQLite bug: no error code or string is available here */
+ PyErr_SetString(OperationalError, "Error creating function");
+ return NULL;
+ } else {
+ PyDict_SetItem(self->function_pinboard, func, Py_None);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
}
PyObject* connection_create_aggregate(Connection* self, PyObject* args, PyObject* kwargs)
@@ -639,7 +688,8 @@
rc = sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_step_callback, &_final_callback);
if (rc != SQLITE_OK) {
- _seterror(self->db);
+ /* Workaround for SQLite bug: no error code or string is available here */
+ PyErr_SetString(OperationalError, "Error creating aggregate");
return NULL;
} else {
PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None);
@@ -682,7 +732,6 @@
static int connection_set_isolation_level(Connection* self, PyObject* isolation_level)
{
- PyObject* empty;
PyObject* res;
PyObject* begin_statement;
@@ -697,15 +746,10 @@
Py_INCREF(Py_None);
self->isolation_level = Py_None;
- empty = PyTuple_New(0);
- if (!empty) {
- return -1;
- }
- res = connection_commit(self, empty);
+ res = connection_commit(self, NULL);
if (!res) {
return -1;
}
- Py_DECREF(empty);
Py_DECREF(res);
self->inTransaction = 0;
@@ -738,12 +782,15 @@
{
PyObject* sql;
Statement* statement;
+ PyObject* weakref;
int rc;
if (!PyArg_ParseTuple(args, "O", &sql)) {
return NULL;
}
+ _drop_unused_statement_references(self);
+
statement = PyObject_New(Statement, &StatementType);
if (!statement) {
return NULL;
@@ -762,8 +809,24 @@
Py_DECREF(statement);
statement = 0;
+ } else {
+ weakref = PyWeakref_NewRef((PyObject*)statement, NULL);
+ if (!weakref) {
+ Py_DECREF(statement);
+ statement = 0;
+ goto error;
+ }
+
+ if (PyList_Append(self->statements, weakref) != 0) {
+ Py_DECREF(weakref);
+ statement = 0;
+ goto error;
+ }
+
+ Py_DECREF(weakref);
}
+error:
return (PyObject*)statement;
}
@@ -983,7 +1046,7 @@
}
static char connection_doc[] =
-PyDoc_STR("<missing docstring>");
+PyDoc_STR("SQLite database connection object.");
static PyGetSetDef connection_getset[] = {
{"isolation_level", (getter)connection_get_isolation_level, (setter)connection_set_isolation_level},
@@ -1011,7 +1074,7 @@
{"executescript", (PyCFunction)connection_executescript, METH_VARARGS,
PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
{"create_collation", (PyCFunction)connection_create_collation, METH_VARARGS,
- PyDoc_STR("Creates a collation function.")},
+ PyDoc_STR("Creates a collation function. Non-standard.")},
{NULL, NULL}
};