#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"

#define ACTION_FINALIZE 1

#define ACTION_RESET 2

#if SQLITE_VERSION_NUMBER >= 3003008

#ifndef SQLITE_OMIT_LOAD_EXTENSION

#define HAVE_LOAD_EXTENSION

#if SQLITE_VERSION_NUMBER >= 3006011

#define HAVE_BACKUP_API

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

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

#if SQLITE_VERSION_NUMBER >= 3003003

sqlite3_result_error(ctx, errmsg, len);

PyErr_SetString(pysqlite_OperationalError, errmsg);

}

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

};

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;

}

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

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

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

rc = sqlite3_open(database, &self->db);

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

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;

return 0;

}

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

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

}

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_CallFunctionObjArgs(factory, (PyObject *)self, NULL);

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;

}

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

return NULL;

} else {

self->db = NULL;

}

}

Py_RETURN_NONE;

}

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

const char *str = PyUnicode_AsUTF8(py_val);

if (str == NULL)

return -1;

sqlite3_result_text(context, str, -1, 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;

const char* val_str;

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 = _pysqlite_long_from_int64(sqlite3_value_int64(cur_value));

break;

case SQLITE_FLOAT:

cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));

break;

case SQLITE_TEXT:

val_str = (const char*)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;

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

Py_DECREF(args);

return NULL;

}

PyTuple_SetItem(args, i, cur_py_value);

}

return args;

}

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

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

#if SQLITE_VERSION_NUMBER < 3003003

/* with old SQLite versions, _sqlite3_result_error() sets a new Python

restore = 0;

}

if (restore) {

/* Restore the exception (if any) of the last call to step(),

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

}

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;

if (sqlite3_libversion_number() < 3008003) {

PyErr_SetString(pysqlite_NotSupportedError,

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

return NULL;

}

flags |= SQLITE_DETERMINISTIC;

}

rc = sqlite3_create_function(self->db,

name,

narg,

flags,

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

return NULL;

} else {

if (PyDict_SetItem(self->function_pinboard, func, Py_None) == -1)

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;

}

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

return NULL;

} else {

if (PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None) == -1)

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,

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

}

static PyObject* pysqlite_connection_set_authorizer(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

{

PyObject* authorizer_cb;

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

int rc;

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