connection.c

/* connection.c - the connection type
 *
 * Copyright (C) 2004-2010 Gerhard Häring <gh@ghaering.de>
 *
 * This file is part of pysqlite.
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */

#include"cache.h"
#include"module.h"
#include"structmember.h"
#include"connection.h"
#include"statement.h"
#include"cursor.h"
#include"prepare_protocol.h"
#include"util.h"

#include"pythread.h"

#defineACTION_FINALIZE 1
#defineACTION_RESET 2

#ifSQLITE_VERSION_NUMBER >= 3003008
#ifndefSQLITE_OMIT_LOAD_EXTENSION
#defineHAVE_LOAD_EXTENSION
#endif
#endif

#ifSQLITE_VERSION_NUMBER >= 3006011
#defineHAVE_BACKUP_API
#endif

_Py_IDENTIFIER(cursor);

staticconstchar*constbegin_statements[] = {
"BEGIN ",
"BEGIN DEFERRED",
"BEGIN IMMEDIATE",
"BEGIN EXCLUSIVE",
NULL
};

staticintpysqlite_connection_set_isolation_level(pysqlite_Connection*self, PyObject*isolation_level, void*Py_UNUSED(ignored));
staticvoid_pysqlite_drop_unused_cursor_references(pysqlite_Connection*self);


staticvoid_sqlite3_result_error(sqlite3_context*ctx, constchar*errmsg, intlen)
{
/* in older SQLite versions, calling sqlite3_result_error in callbacks
 * triggers a bug in SQLite that leads either to irritating results or
 * segfaults, depending on the SQLite version */
#ifSQLITE_VERSION_NUMBER >= 3003003
sqlite3_result_error(ctx, errmsg, len);
#else
PyErr_SetString(pysqlite_OperationalError, errmsg);
#endif
}

intpysqlite_connection_init(pysqlite_Connection*self, PyObject*args, PyObject*kwargs)
{
staticchar*kwlist[] = {
"database", "timeout", "detect_types", "isolation_level",
"check_same_thread", "factory", "cached_statements", "uri",
NULL
 };

char*database;
PyObject*database_obj;
intdetect_types=0;
PyObject*isolation_level=NULL;
PyObject*factory=NULL;
intcheck_same_thread=1;
intcached_statements=100;
inturi=0;
doubletimeout=5.0;
intrc;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|diOiOip", kwlist,
PyUnicode_FSConverter, &database_obj, &timeout, &detect_types,
&isolation_level, &check_same_thread,
&factory, &cached_statements, &uri))
 {
return-1;
 }

database=PyBytes_AsString(database_obj);

self->initialized=1;

self->begin_statement=NULL;

Py_CLEAR(self->statement_cache);
Py_CLEAR(self->statements);
Py_CLEAR(self->cursors);

Py_INCREF(Py_None);
Py_XSETREF(self->row_factory, Py_None);

Py_INCREF(&PyUnicode_Type);
Py_XSETREF(self->text_factory, (PyObject*)&PyUnicode_Type);

#ifdefSQLITE_OPEN_URI
Py_BEGIN_ALLOW_THREADS
rc=sqlite3_open_v2(database, &self->db,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
 (uri ? SQLITE_OPEN_URI : 0), NULL);
#else
if (uri) {
PyErr_SetString(pysqlite_NotSupportedError, "URIs not supported");
return-1;
 }
Py_BEGIN_ALLOW_THREADS
/* No need to use sqlite3_open_v2 as sqlite3_open(filename, db) is the
 same as sqlite3_open_v2(filename, db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, NULL). */
rc=sqlite3_open(database, &self->db);
#endif
Py_END_ALLOW_THREADS

Py_DECREF(database_obj);

if (rc!=SQLITE_OK) {
_pysqlite_seterror(self->db, NULL);
return-1;
 }

if (!isolation_level) {
isolation_level=PyUnicode_FromString("");
if (!isolation_level) {
return-1;
 }
 } else {
Py_INCREF(isolation_level);
 }
Py_CLEAR(self->isolation_level);
if (pysqlite_connection_set_isolation_level(self, isolation_level, NULL) <0) {
Py_DECREF(isolation_level);
return-1;
 }
Py_DECREF(isolation_level);

self->statement_cache= (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements);
if (PyErr_Occurred()) {
return-1;
 }

self->created_statements=0;
self->created_cursors=0;

/* Create lists of weak references to statements/cursors */
self->statements=PyList_New(0);
self->cursors=PyList_New(0);
if (!self->statements|| !self->cursors) {
return-1;
 }

/* 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
 * cache class to not decref the factory (self) in its deallocator.
 */
self->statement_cache->decref_factory=0;
Py_DECREF(self);

self->detect_types=detect_types;
self->timeout=timeout;
 (void)sqlite3_busy_timeout(self->db, (int)(timeout*1000));
self->thread_ident=PyThread_get_thread_ident();
if (!check_same_thread&&sqlite3_libversion_number() <3003001) {
PyErr_SetString(pysqlite_NotSupportedError, "shared connections not available");
return-1;
 }
self->check_same_thread=check_same_thread;

Py_XSETREF(self->function_pinboard, PyDict_New());
if (!self->function_pinboard) {
return-1;
 }

Py_XSETREF(self->collations, PyDict_New());
if (!self->collations) {
return-1;
 }

self->Warning=pysqlite_Warning;
self->Error=pysqlite_Error;
self->InterfaceError=pysqlite_InterfaceError;
self->DatabaseError=pysqlite_DatabaseError;
self->DataError=pysqlite_DataError;
self->OperationalError=pysqlite_OperationalError;
self->IntegrityError=pysqlite_IntegrityError;
self->InternalError=pysqlite_InternalError;
self->ProgrammingError=pysqlite_ProgrammingError;
self->NotSupportedError=pysqlite_NotSupportedError;

return0;
}

/* action in (ACTION_RESET, ACTION_FINALIZE) */
voidpysqlite_do_all_statements(pysqlite_Connection*self, intaction, intreset_cursors)
{
inti;
PyObject*weakref;
PyObject*statement;
pysqlite_Cursor*cursor;

for (i=0; i<PyList_Size(self->statements); i++) {
weakref=PyList_GetItem(self->statements, i);
statement=PyWeakref_GetObject(weakref);
if (statement!=Py_None) {
Py_INCREF(statement);
if (action==ACTION_RESET) {
 (void)pysqlite_statement_reset((pysqlite_Statement*)statement);
 } else {
 (void)pysqlite_statement_finalize((pysqlite_Statement*)statement);
 }
Py_DECREF(statement);
 }
 }

if (reset_cursors) {
for (i=0; i<PyList_Size(self->cursors); i++) {
weakref=PyList_GetItem(self->cursors, i);
cursor= (pysqlite_Cursor*)PyWeakref_GetObject(weakref);
if ((PyObject*)cursor!=Py_None) {
cursor->reset=1;
 }
 }
 }
}

voidpysqlite_connection_dealloc(pysqlite_Connection*self)
{
Py_XDECREF(self->statement_cache);

/* Clean up if user has not called .close() explicitly. */
if (self->db) {
Py_BEGIN_ALLOW_THREADS
SQLITE3_CLOSE(self->db);
Py_END_ALLOW_THREADS
 }

Py_XDECREF(self->isolation_level);
Py_XDECREF(self->function_pinboard);
Py_XDECREF(self->row_factory);
Py_XDECREF(self->text_factory);
Py_XDECREF(self->collations);
Py_XDECREF(self->statements);
Py_XDECREF(self->cursors);

Py_TYPE(self)->tp_free((PyObject*)self);
}

/*
 * Registers a cursor with the connection.
 *
 * 0 => error; 1 => ok
 */
intpysqlite_connection_register_cursor(pysqlite_Connection*connection, PyObject*cursor)
{
PyObject*weakref;

weakref=PyWeakref_NewRef((PyObject*)cursor, NULL);
if (!weakref) {
 goto error;
 }

if (PyList_Append(connection->cursors, weakref) !=0) {
Py_CLEAR(weakref);
 goto error;
 }

Py_DECREF(weakref);

return1;
error:
return0;
}

PyObject*pysqlite_connection_cursor(pysqlite_Connection*self, PyObject*args, PyObject*kwargs)
{
staticchar*kwlist[] = {"factory", NULL};
PyObject*factory=NULL;
PyObject*cursor;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist,
&factory)) {
returnNULL;
 }

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
returnNULL;
 }

if (factory==NULL) {
factory= (PyObject*)&pysqlite_CursorType;
 }

cursor=PyObject_CallFunctionObjArgs(factory, (PyObject*)self, NULL);
if (cursor==NULL)
returnNULL;
if (!PyObject_TypeCheck(cursor, &pysqlite_CursorType)) {
PyErr_Format(PyExc_TypeError,
"factory must return a cursor, not %.100s",
Py_TYPE(cursor)->tp_name);
Py_DECREF(cursor);
returnNULL;
 }

_pysqlite_drop_unused_cursor_references(self);

if (cursor&&self->row_factory!=Py_None) {
Py_INCREF(self->row_factory);
Py_XSETREF(((pysqlite_Cursor*)cursor)->row_factory, self->row_factory);
 }

returncursor;
}

PyObject*pysqlite_connection_close(pysqlite_Connection*self, PyObject*args)
{
intrc;

if (!pysqlite_check_thread(self)) {
returnNULL;
 }

pysqlite_do_all_statements(self, ACTION_FINALIZE, 1);

if (self->db) {
Py_BEGIN_ALLOW_THREADS
rc=SQLITE3_CLOSE(self->db);
Py_END_ALLOW_THREADS

if (rc!=SQLITE_OK) {
_pysqlite_seterror(self->db, NULL);
returnNULL;
 } else {
self->db=NULL;
 }
 }

Py_RETURN_NONE;
}

/*
 * Checks if a connection object is usable (i. e. not closed).
 *
 * 0 => error; 1 => ok
 */
intpysqlite_check_connection(pysqlite_Connection*con)
{
if (!con->initialized) {
PyErr_SetString(pysqlite_ProgrammingError, "Base Connection.__init__ not called.");
return0;
 }

if (!con->db) {
PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database.");
return0;
 } else {
return1;
 }
}

PyObject*_pysqlite_connection_begin(pysqlite_Connection*self)
{
intrc;
constchar*tail;
sqlite3_stmt*statement;

Py_BEGIN_ALLOW_THREADS
rc=sqlite3_prepare_v2(self->db, self->begin_statement, -1, &statement, &tail);
Py_END_ALLOW_THREADS

if (rc!=SQLITE_OK) {
_pysqlite_seterror(self->db, statement);
 goto error;
 }

rc=pysqlite_step(statement, self);
if (rc!=SQLITE_DONE) {
_pysqlite_seterror(self->db, statement);
 }

Py_BEGIN_ALLOW_THREADS
rc=sqlite3_finalize(statement);
Py_END_ALLOW_THREADS

if (rc!=SQLITE_OK&& !PyErr_Occurred()) {
_pysqlite_seterror(self->db, NULL);
 }

error:
if (PyErr_Occurred()) {
returnNULL;
 } else {
Py_RETURN_NONE;
 }
}

PyObject*pysqlite_connection_commit(pysqlite_Connection*self, PyObject*args)
{
intrc;
constchar*tail;
sqlite3_stmt*statement;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
returnNULL;
 }

if (!sqlite3_get_autocommit(self->db)) {

Py_BEGIN_ALLOW_THREADS
rc=sqlite3_prepare_v2(self->db, "COMMIT", -1, &statement, &tail);
Py_END_ALLOW_THREADS
if (rc!=SQLITE_OK) {
_pysqlite_seterror(self->db, NULL);
 goto error;
 }

rc=pysqlite_step(statement, self);
if (rc!=SQLITE_DONE) {
_pysqlite_seterror(self->db, statement);
 }

Py_BEGIN_ALLOW_THREADS
rc=sqlite3_finalize(statement);
Py_END_ALLOW_THREADS
if (rc!=SQLITE_OK&& !PyErr_Occurred()) {
_pysqlite_seterror(self->db, NULL);
 }

 }

error:
if (PyErr_Occurred()) {
returnNULL;
 } else {
Py_RETURN_NONE;
 }
}

PyObject*pysqlite_connection_rollback(pysqlite_Connection*self, PyObject*args)
{
intrc;
constchar*tail;
sqlite3_stmt*statement;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
returnNULL;
 }

if (!sqlite3_get_autocommit(self->db)) {
pysqlite_do_all_statements(self, ACTION_RESET, 1);

Py_BEGIN_ALLOW_THREADS
rc=sqlite3_prepare_v2(self->db, "ROLLBACK", -1, &statement, &tail);
Py_END_ALLOW_THREADS
if (rc!=SQLITE_OK) {
_pysqlite_seterror(self->db, NULL);
 goto error;
 }

rc=pysqlite_step(statement, self);
if (rc!=SQLITE_DONE) {
_pysqlite_seterror(self->db, statement);
 }

Py_BEGIN_ALLOW_THREADS
rc=sqlite3_finalize(statement);
Py_END_ALLOW_THREADS
if (rc!=SQLITE_OK&& !PyErr_Occurred()) {
_pysqlite_seterror(self->db, NULL);
 }

 }

error:
if (PyErr_Occurred()) {
returnNULL;
 } else {
Py_RETURN_NONE;
 }
}

staticint
_pysqlite_set_result(sqlite3_context*context, PyObject*py_val)
{
if (py_val==Py_None) {
sqlite3_result_null(context);
 } elseif (PyLong_Check(py_val)) {
sqlite_int64value=_pysqlite_long_as_int64(py_val);
if (value==-1&&PyErr_Occurred())
return-1;
sqlite3_result_int64(context, value);
 } elseif (PyFloat_Check(py_val)) {
sqlite3_result_double(context, PyFloat_AsDouble(py_val));
 } elseif (PyUnicode_Check(py_val)) {
constchar*str=PyUnicode_AsUTF8(py_val);
if (str==NULL)
return-1;
sqlite3_result_text(context, str, -1, SQLITE_TRANSIENT);
 } elseif (PyObject_CheckBuffer(py_val)) {
Py_bufferview;
if (PyObject_GetBuffer(py_val, &view, PyBUF_SIMPLE) !=0) {
PyErr_SetString(PyExc_ValueError,
"could not convert BLOB to buffer");
return-1;
 }
if (view.len>INT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"BLOB longer than INT_MAX bytes");
PyBuffer_Release(&view);
return-1;
 }
sqlite3_result_blob(context, view.buf, (int)view.len, SQLITE_TRANSIENT);
PyBuffer_Release(&view);
 } else {
return-1;
 }
return0;
}

PyObject*_pysqlite_build_py_params(sqlite3_context*context, intargc, sqlite3_value**argv)
{
PyObject*args;
inti;
sqlite3_value*cur_value;
PyObject*cur_py_value;
constchar*val_str;
Py_ssize_tbuflen;

args=PyTuple_New(argc);
if (!args) {
returnNULL;
 }

for (i=0; i<argc; i++) {
cur_value=argv[i];
switch (sqlite3_value_type(argv[i])) {
caseSQLITE_INTEGER:
cur_py_value=_pysqlite_long_from_int64(sqlite3_value_int64(cur_value));
break;
caseSQLITE_FLOAT:
cur_py_value=PyFloat_FromDouble(sqlite3_value_double(cur_value));
break;
caseSQLITE_TEXT:
val_str= (constchar*)sqlite3_value_text(cur_value);
cur_py_value=PyUnicode_FromString(val_str);
/* TODO: have a way to show errors here */
if (!cur_py_value) {
PyErr_Clear();
Py_INCREF(Py_None);
cur_py_value=Py_None;
 }
break;
caseSQLITE_BLOB:
buflen=sqlite3_value_bytes(cur_value);
cur_py_value=PyBytes_FromStringAndSize(
sqlite3_value_blob(cur_value), buflen);
break;
caseSQLITE_NULL:
default:
Py_INCREF(Py_None);
cur_py_value=Py_None;
 }

if (!cur_py_value) {
Py_DECREF(args);
returnNULL;
 }

PyTuple_SetItem(args, i, cur_py_value);

 }

returnargs;
}

void_pysqlite_func_callback(sqlite3_context*context, intargc, sqlite3_value**argv)
{
PyObject*args;
PyObject*py_func;
PyObject*py_retval=NULL;
intok;

PyGILState_STATEthreadstate;

threadstate=PyGILState_Ensure();

py_func= (PyObject*)sqlite3_user_data(context);

args=_pysqlite_build_py_params(context, argc, argv);
if (args) {
py_retval=PyObject_CallObject(py_func, args);
Py_DECREF(args);
 }

ok=0;
if (py_retval) {
ok=_pysqlite_set_result(context, py_retval) ==0;
Py_DECREF(py_retval);
 }
if (!ok) {
if (_pysqlite_enable_callback_tracebacks) {
PyErr_Print();
 } else {
PyErr_Clear();
 }
_sqlite3_result_error(context, "user-defined function raised exception", -1);
 }

PyGILState_Release(threadstate);
}

staticvoid_pysqlite_step_callback(sqlite3_context*context, intargc, sqlite3_value**params)
{
PyObject*args;
PyObject*function_result=NULL;
PyObject*aggregate_class;
PyObject**aggregate_instance;
PyObject*stepmethod=NULL;

PyGILState_STATEthreadstate;

threadstate=PyGILState_Ensure();

aggregate_class= (PyObject*)sqlite3_user_data(context);

aggregate_instance= (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));

if (*aggregate_instance==NULL) {
*aggregate_instance=_PyObject_CallNoArg(aggregate_class);

if (PyErr_Occurred()) {
*aggregate_instance=0;
if (_pysqlite_enable_callback_tracebacks) {
PyErr_Print();
 } else {
PyErr_Clear();
 }
_sqlite3_result_error(context, "user-defined aggregate's '__init__' method raised error", -1);
 goto error;
 }
 }

stepmethod=PyObject_GetAttrString(*aggregate_instance, "step");
if (!stepmethod) {
 goto error;
 }

args=_pysqlite_build_py_params(context, argc, params);
if (!args) {
 goto error;
 }

function_result=PyObject_CallObject(stepmethod, args);
Py_DECREF(args);

if (!function_result) {
if (_pysqlite_enable_callback_tracebacks) {
PyErr_Print();
 } else {
PyErr_Clear();
 }
_sqlite3_result_error(context, "user-defined aggregate's 'step' method raised error", -1);
 }

error:
Py_XDECREF(stepmethod);
Py_XDECREF(function_result);

PyGILState_Release(threadstate);
}

void_pysqlite_final_callback(sqlite3_context*context)
{
PyObject*function_result;
PyObject**aggregate_instance;
_Py_IDENTIFIER(finalize);
intok;
PyObject*exception, *value, *tb;
intrestore;

PyGILState_STATEthreadstate;

threadstate=PyGILState_Ensure();

aggregate_instance= (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
if (!*aggregate_instance) {
/* this branch is executed if there was an exception in the aggregate's
 * __init__ */

 goto error;
 }

/* Keep the exception (if any) of the last call to step() */
PyErr_Fetch(&exception, &value, &tb);
restore=1;

function_result=_PyObject_CallMethodId(*aggregate_instance, &PyId_finalize, NULL);

Py_DECREF(*aggregate_instance);

ok=0;
if (function_result) {
ok=_pysqlite_set_result(context, function_result) ==0;
Py_DECREF(function_result);
 }
if (!ok) {
if (_pysqlite_enable_callback_tracebacks) {
PyErr_Print();
 } else {
PyErr_Clear();
 }
_sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1);
#ifSQLITE_VERSION_NUMBER<3003003
/* with old SQLite versions, _sqlite3_result_error() sets a new Python
 exception, so don't restore the previous exception */
restore=0;
#endif
 }

if (restore) {
/* Restore the exception (if any) of the last call to step(),
 but clear also the current exception if finalize() failed */
PyErr_Restore(exception, value, tb);
 }

error:
PyGILState_Release(threadstate);
}

staticvoid_pysqlite_drop_unused_statement_references(pysqlite_Connection*self)
{
PyObject*new_list;
PyObject*weakref;
inti;

/* 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 (PyWeakref_GetObject(weakref) !=Py_None) {
if (PyList_Append(new_list, weakref) !=0) {
Py_DECREF(new_list);
return;
 }
 }
 }

Py_SETREF(self->statements, new_list);
}

staticvoid_pysqlite_drop_unused_cursor_references(pysqlite_Connection*self)
{
PyObject*new_list;
PyObject*weakref;
inti;

/* we only need to do this once in a while */
if (self->created_cursors++<200) {
return;
 }

self->created_cursors=0;

new_list=PyList_New(0);
if (!new_list) {
return;
 }

for (i=0; i<PyList_Size(self->cursors); i++) {
weakref=PyList_GetItem(self->cursors, i);
if (PyWeakref_GetObject(weakref) !=Py_None) {
if (PyList_Append(new_list, weakref) !=0) {
Py_DECREF(new_list);
return;
 }
 }
 }

Py_SETREF(self->cursors, new_list);
}

PyObject*pysqlite_connection_create_function(pysqlite_Connection*self, PyObject*args, PyObject*kwargs)
{
staticchar*kwlist[] = {"name", "narg", "func", NULL, NULL};

PyObject*func;
char*name;
intnarg;
intrc;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
returnNULL;
 }

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO", kwlist,
&name, &narg, &func))
 {
returnNULL;
 }

if (PyDict_SetItem(self->function_pinboard, func, Py_None) ==-1) {
returnNULL;
 }
rc=sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _pysqlite_func_callback, NULL, NULL);

if (rc!=SQLITE_OK) {
/* Workaround for SQLite bug: no error code or string is available here */
PyErr_SetString(pysqlite_OperationalError, "Error creating function");
returnNULL;
 }
Py_RETURN_NONE;
}

PyObject*pysqlite_connection_create_aggregate(pysqlite_Connection*self, PyObject*args, PyObject*kwargs)
{
PyObject*aggregate_class;

intn_arg;
char*name;
staticchar*kwlist[] = { "name", "n_arg", "aggregate_class", NULL };
intrc;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
returnNULL;
 }

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO:create_aggregate",
kwlist, &name, &n_arg, &aggregate_class)) {
returnNULL;
 }

if (PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None) ==-1) {
returnNULL;
 }
rc=sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_pysqlite_step_callback, &_pysqlite_final_callback);
if (rc!=SQLITE_OK) {
/* Workaround for SQLite bug: no error code or string is available here */
PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");
returnNULL;
 }
Py_RETURN_NONE;
}

staticint_authorizer_callback(void*user_arg, intaction, constchar*arg1, constchar*arg2 , constchar*dbname, constchar*access_attempt_source)
{
PyObject*ret;
intrc;
PyGILState_STATEgilstate;

gilstate=PyGILState_Ensure();

ret=PyObject_CallFunction((PyObject*)user_arg, "issss", action, arg1, arg2, dbname, access_attempt_source);

if (ret==NULL) {
if (_pysqlite_enable_callback_tracebacks)
PyErr_Print();
else
PyErr_Clear();

rc=SQLITE_DENY;
 }
else {
if (PyLong_Check(ret)) {
rc=_PyLong_AsInt(ret);
if (rc==-1&&PyErr_Occurred()) {
if (_pysqlite_enable_callback_tracebacks)
PyErr_Print();
else
PyErr_Clear();
rc=SQLITE_DENY;
 }
 }
else {
rc=SQLITE_DENY;
 }
Py_DECREF(ret);
 }

PyGILState_Release(gilstate);
returnrc;
}

staticint_progress_handler(void*user_arg)
{
intrc;
PyObject*ret;
PyGILState_STATEgilstate;

gilstate=PyGILState_Ensure();
ret=_PyObject_CallNoArg((PyObject*)user_arg);

if (!ret) {
if (_pysqlite_enable_callback_tracebacks) {
PyErr_Print();
 } else {
PyErr_Clear();
 }

/* abort query if error occurred */
rc=1;
 } else {
rc= (int)PyObject_IsTrue(ret);
Py_DECREF(ret);
 }

PyGILState_Release(gilstate);
returnrc;
}

staticvoid_trace_callback(void*user_arg, constchar*statement_string)
{
PyObject*py_statement=NULL;
PyObject*ret=NULL;

PyGILState_STATEgilstate;

gilstate=PyGILState_Ensure();
py_statement=PyUnicode_DecodeUTF8(statement_string,
strlen(statement_string), "replace");
if (py_statement) {
ret=PyObject_CallFunctionObjArgs((PyObject*)user_arg, py_statement, NULL);
Py_DECREF(py_statement);
 }

if (ret) {
Py_DECREF(ret);
 } else {
if (_pysqlite_enable_callback_tracebacks) {
PyErr_Print();
 } else {
PyErr_Clear();
 }
 }

PyGILState_Release(gilstate);
}

staticPyObject*pysqlite_connection_set_authorizer(pysqlite_Connection*self, PyObject*args, PyObject*kwargs)
{
PyObject*authorizer_cb;

staticchar*kwlist[] = { "authorizer_callback", NULL };
intrc;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
returnNULL;
 }

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_authorizer",
kwlist, &authorizer_cb)) {
returnNULL;
 }

if (PyDict_SetItem(self->function_pinboard, authorizer_cb, Py_None) ==-1) {
returnNULL;
 }
rc=sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb);
if (rc!=SQLITE_OK) {
PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback");
returnNULL;
 }
Py_RETURN_NONE;
}

staticPyObject*pysqlite_connection_set_progress_handler(pysqlite_Connection*self, PyObject*args, PyObject*kwargs)
{
PyObject*progress_handler;
intn;

staticchar*kwlist[] = { "progress_handler", "n", NULL };