/* 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" // PyMemberDef

#include "connection.h"

#include "statement.h"

#include "cursor.h"

#include "prepare_protocol.h"

#include "util.h"

#define ACTION_FINALIZE 1

#define ACTION_RESET 2

#if SQLITE_VERSION_NUMBER >= 3003008

#ifndef SQLITE_OMIT_LOAD_EXTENSION

#define HAVE_LOAD_EXTENSION

#endif

#endif

#if SQLITE_VERSION_NUMBER >= 3006011

#define HAVE_BACKUP_API

#endif

_Py_IDENTIFIER(cursor);

static const char * const begin_statements[] = {

"BEGIN ",

"BEGIN DEFERRED",

"BEGIN IMMEDIATE",

"BEGIN EXCLUSIVE",

NULL

};

static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored));

static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self);

static void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len)

{

/* 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 */

#if SQLITE_VERSION_NUMBER >= 3003003

sqlite3_result_error(ctx, errmsg, len);

#else

PyErr_SetString(pysqlite_OperationalError, errmsg);

#endif

}

int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

{

static char *kwlist[] = {

"database", "timeout", "detect_types", "isolation_level",

"check_same_thread", "factory", "cached_statements", "uri",

NULL

};

const char* database;

PyObject* database_obj;

int detect_types = 0;

PyObject* isolation_level = NULL;

PyObject* factory = NULL;

int check_same_thread = 1;

int cached_statements = 100;

int uri = 0;

double timeout = 5.0;

int rc;

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;

}

if (PySys_Audit("sqlite3.connect", "O", database_obj) < 0) {

Py_DECREF(database_obj);

return -1;

}

database = PyBytes_AsString(database_obj);

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);

#ifdef SQLITE_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 (self->db == NULL && rc == SQLITE_NOMEM) {

PyErr_NoMemory();

return -1;

}

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;

self->function_pinboard_trace_callback = NULL;

self->function_pinboard_progress_handler = NULL;

self->function_pinboard_authorizer_cb = NULL;

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;

self->initialized = 1;

return 0;

}

/* action in (ACTION_RESET, ACTION_FINALIZE) */

void pysqlite_do_all_statements(pysqlite_Connection* self, int action, int reset_cursors)

{

int i;

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;

}

}

}

}

void pysqlite_connection_dealloc(pysqlite_Connection* self)

{

Py_XDECREF(self->statement_cache);

/* Clean up if user has not called .close() explicitly. */

if (self->db) {

SQLITE3_CLOSE(self->db);

}

Py_XDECREF(self->isolation_level);

Py_XDECREF(self->function_pinboard_trace_callback);

Py_XDECREF(self->function_pinboard_progress_handler);

Py_XDECREF(self->function_pinboard_authorizer_cb);

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

*/

int pysqlite_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);

return 1;

error:

return 0;

}

PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

{

static char *kwlist[] = {"factory", NULL};

PyObject* factory = NULL;

PyObject* cursor;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist,

&factory)) {

return NULL;

}

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

return NULL;

}

if (factory == NULL) {

factory = (PyObject*)&pysqlite_CursorType;

}

cursor = PyObject_CallOneArg(factory, (PyObject *)self);

if (cursor == NULL)

return NULL;

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);

return NULL;

}

_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);

}

return cursor;

}

PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args)

{

int rc;

if (!pysqlite_check_thread(self)) {

return NULL;

}

if (!self->initialized) {

PyErr_SetString(pysqlite_ProgrammingError,

"Base Connection.__init__ not called.");

return NULL;

}

pysqlite_do_all_statements(self, ACTION_FINALIZE, 1);

if (self->db) {

rc = SQLITE3_CLOSE(self->db);

if (rc != SQLITE_OK) {

_pysqlite_seterror(self->db, NULL);

return NULL;

} else {

self->db = NULL;

}

}

Py_RETURN_NONE;

}

/*

* Checks if a connection object is usable (i. e. not closed).

*

* 0 => error; 1 => ok

*/

int pysqlite_check_connection(pysqlite_Connection* con)

{

if (!con->initialized) {

PyErr_SetString(pysqlite_ProgrammingError, "Base Connection.__init__ not called.");

return 0;

}

if (!con->db) {

PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database.");

return 0;

} else {

return 1;

}

}

PyObject* _pysqlite_connection_begin(pysqlite_Connection* self)

{

int rc;

const char* 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()) {

return NULL;

} else {

Py_RETURN_NONE;

}

}

PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args)

{

int rc;

const char* tail;

sqlite3_stmt* statement;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

return NULL;

}

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()) {

return NULL;

} else {

Py_RETURN_NONE;

}

}

PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args)

{

int rc;

const char* tail;

sqlite3_stmt* statement;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

return NULL;

}

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()) {

return NULL;

} else {

Py_RETURN_NONE;

}

}

static int

_pysqlite_set_result(sqlite3_context* context, PyObject* py_val)

{

if (py_val == Py_None) {

sqlite3_result_null(context);

} else if (PyLong_Check(py_val)) {

sqlite_int64 value = _pysqlite_long_as_int64(py_val);

if (value == -1 && PyErr_Occurred())

return -1;

sqlite3_result_int64(context, value);

} else if (PyFloat_Check(py_val)) {

sqlite3_result_double(context, PyFloat_AsDouble(py_val));

} else if (PyUnicode_Check(py_val)) {

Py_ssize_t sz;

const char *str = PyUnicode_AsUTF8AndSize(py_val, &sz);

if (str == NULL) {

return -1;

}

if (sz > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"string is longer than INT_MAX bytes");

return -1;

}

sqlite3_result_text(context, str, (int)sz, SQLITE_TRANSIENT);

} else if (PyObject_CheckBuffer(py_val)) {

Py_buffer view;

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;

}

return 0;

}

PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv)

{

PyObject* args;

int i;

sqlite3_value* cur_value;

PyObject* cur_py_value;

Py_ssize_t buflen;

args = PyTuple_New(argc);

if (!args) {

return NULL;

}

for (i = 0; i < argc; i++) {

cur_value = argv[i];

switch (sqlite3_value_type(argv[i])) {

case SQLITE_INTEGER:

cur_py_value = PyLong_FromLongLong(sqlite3_value_int64(cur_value));

break;

case SQLITE_FLOAT:

cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));

break;

case SQLITE_TEXT: {

sqlite3 *db = sqlite3_context_db_handle(context);

const char *text = (const char *)sqlite3_value_text(cur_value);

if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {

PyErr_NoMemory();

goto error;

}

Py_ssize_t size = sqlite3_value_bytes(cur_value);

cur_py_value = PyUnicode_FromStringAndSize(text, size);

break;

}

case SQLITE_BLOB:

buflen = sqlite3_value_bytes(cur_value);

cur_py_value = PyBytes_FromStringAndSize(

sqlite3_value_blob(cur_value), buflen);

break;

case SQLITE_NULL:

default:

Py_INCREF(Py_None);

cur_py_value = Py_None;

}

if (!cur_py_value) {

goto error;

}

PyTuple_SetItem(args, i, cur_py_value);

}

return args;

error:

Py_DECREF(args);

return NULL;

}

void _pysqlite_func_callback(sqlite3_context* context, int argc, sqlite3_value** argv)

{

PyObject* args;

PyObject* py_func;

PyObject* py_retval = NULL;

int ok;

PyGILState_STATE threadstate;

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);

}

static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params)

{

PyObject* args;

PyObject* function_result = NULL;

PyObject* aggregate_class;

PyObject** aggregate_instance;

PyObject* stepmethod = NULL;

PyGILState_STATE threadstate;

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);

int ok;

PyObject *exception, *value, *tb;

int restore;

PyGILState_STATE threadstate;

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_CallMethodIdNoArgs(*aggregate_instance, &PyId_finalize);

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);

#if SQLITE_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);

}

static void _pysqlite_drop_unused_statement_references(pysqlite_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 (PyWeakref_GetObject(weakref) != Py_None) {

if (PyList_Append(new_list, weakref) != 0) {

Py_DECREF(new_list);

return;

}

}

}

Py_SETREF(self->statements, new_list);

}

static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self)

{

PyObject* new_list;

PyObject* weakref;

int i;

/* 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);

}

static void _destructor(void* args)

{

Py_DECREF((PyObject*)args);

}

PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

{

static char *kwlist[] = {"name", "narg", "func", "deterministic", NULL};

PyObject* func;

char* name;

int narg;

int rc;

int deterministic = 0;

int flags = SQLITE_UTF8;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

return NULL;

}

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO|$p", kwlist,

&name, &narg, &func, &deterministic))

{

return NULL;

}

if (deterministic) {

#if SQLITE_VERSION_NUMBER < 3008003

PyErr_SetString(pysqlite_NotSupportedError,

"deterministic=True requires SQLite 3.8.3 or higher");

return NULL;

#else

if (sqlite3_libversion_number() < 3008003) {

PyErr_SetString(pysqlite_NotSupportedError,

"deterministic=True requires SQLite 3.8.3 or higher");

return NULL;

}

flags |= SQLITE_DETERMINISTIC;

#endif

}

Py_INCREF(func);

rc = sqlite3_create_function_v2(self->db,

name,

narg,

flags,

(void*)func,

_pysqlite_func_callback,

NULL,

NULL,

&_destructor); // will decref func

if (rc != SQLITE_OK) {

/* Workaround for SQLite bug: no error code or string is available here */

PyErr_SetString(pysqlite_OperationalError, "Error creating function");

return NULL;

}

Py_RETURN_NONE;

}

PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

{

PyObject* aggregate_class;

int n_arg;

char* name;

static char *kwlist[] = { "name", "n_arg", "aggregate_class", NULL };

int rc;

if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {

return NULL;

}

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO:create_aggregate",

kwlist, &name, &n_arg, &aggregate_class)) {

return NULL;

}

Py_INCREF(aggregate_class);

rc = sqlite3_create_function_v2(self->db,

name,

n_arg,

SQLITE_UTF8,

(void*)aggregate_class,

0,

&_pysqlite_step_callback,

&_pysqlite_final_callback,

&_destructor); // will decref func

if (rc != SQLITE_OK) {

/* Workaround for SQLite bug: no error code or string is available here */

PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");

return NULL;

}

Py_RETURN_NONE;

}

static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source)

{

PyObject *ret;

int rc;

PyGILState_STATE gilstate;

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);

return rc;

}

static int _progress_handler(void* user_arg)

{

int rc;

PyObject *ret;

PyGILState_STATE gilstate;

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);

return rc;

}

static void _trace_callback(void* user_arg, const char* statement_string)

{

PyObject *py_statement = NULL;

PyObject *ret = NULL;

PyGILState_STATE gilstate;

gilstate = PyGILState_Ensure();

py_statement = PyUnicode_DecodeUTF8(statement_string,