#include "cache.h"

#include "module.h"

#include "connection.h"

#include "statement.h"

#include "cursor.h"

#include "prepare_protocol.h"

#include "util.h"

#include "sqlitecompat.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

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", NULL, NULL};

PyObject* database;

int detect_types = 0;

PyObject* isolation_level = NULL;

PyObject* factory = NULL;

int check_same_thread = 1;

int cached_statements = 100;

double timeout = 5.0;

int rc;

PyObject* class_attr = NULL;

PyObject* class_attr_str = NULL;

int is_apsw_connection = 0;

PyObject* database_utf8;

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

&database, &timeout, &detect_types, &isolation_level, &check_same_thread, &factory, &cached_statements))

{

return -1;

}

self->initialized = 1;

self->begin_statement = NULL;

self->statement_cache = NULL;

self->statements = NULL;

self->cursors = NULL;

Py_INCREF(Py_None);

self->row_factory = Py_None;

Py_INCREF(&PyUnicode_Type);

self->text_factory = (PyObject*)&PyUnicode_Type;

if (PyString_Check(database) || PyUnicode_Check(database)) {

if (PyString_Check(database)) {

database_utf8 = database;

Py_INCREF(database_utf8);

} else {

database_utf8 = PyUnicode_AsUTF8String(database);

if (!database_utf8) {

return -1;

}

}

Py_BEGIN_ALLOW_THREADS

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

Py_END_ALLOW_THREADS

Py_DECREF(database_utf8);

if (rc != SQLITE_OK) {

_pysqlite_seterror(self->db, NULL);

return -1;

}

} else {

/* Create a pysqlite connection from an APSW connection */

class_attr = PyObject_GetAttrString(database, "__class__");

if (class_attr) {

class_attr_str = PyObject_Str(class_attr);

if (class_attr_str) {

if (strcmp(PyString_AsString(class_attr_str), "<type 'apsw.Connection'>") == 0) {

/* In the APSW Connection object, the first entry after

self->db = ((pysqlite_Connection*)database)->db;

Py_INCREF(database);

self->apsw_connection = database;

is_apsw_connection = 1;

}

}

}

Py_XDECREF(class_attr_str);

Py_XDECREF(class_attr);

if (!is_apsw_connection) {

PyErr_SetString(PyExc_ValueError, "database parameter must be string or APSW Connection object");

return -1;

}

}

if (!isolation_level) {

isolation_level = PyString_FromString("");

if (!isolation_level) {

return -1;

}

} else {

Py_INCREF(isolation_level);

}

self->isolation_level = NULL;

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->inTransaction = 0;

self->detect_types = detect_types;

self->timeout = timeout;

(void)sqlite3_busy_timeout(self->db, (int)(timeout*1000));

#ifdef WITH_THREAD

self->thread_ident = PyThread_get_thread_ident();

self->check_same_thread = check_same_thread;

self->function_pinboard = PyDict_New();

if (!self->function_pinboard) {

return -1;

}

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_flush_statement_cache(pysqlite_Connection* self)

{

pysqlite_Node* node;

pysqlite_Statement* statement;

node = self->statement_cache->first;

while (node) {

statement = (pysqlite_Statement*)(node->data);

(void)pysqlite_statement_finalize(statement);

node = node->next;

}

Py_SETREF(self->statement_cache,

(pysqlite_Cache *)PyObject_CallFunction((PyObject *)&pysqlite_CacheType, "O", self));

Py_DECREF(self);

self->statement_cache->decref_factory = 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) {

if (action == ACTION_RESET) {

(void)pysqlite_statement_reset((pysqlite_Statement*)statement);

} else {

(void)pysqlite_statement_finalize((pysqlite_Statement*)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)

{

PyObject* ret = NULL;

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

} else if (self->apsw_connection) {

ret = PyObject_CallMethod(self->apsw_connection, "close", "");

Py_XDECREF(ret);

Py_XDECREF(self->apsw_connection);

}

if (self->begin_statement) {

PyMem_Free(self->begin_statement);

}

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

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

{

PyObject* ret;

int rc;

if (!pysqlite_check_thread(self)) {

return NULL;

}

pysqlite_do_all_statements(self, ACTION_FINALIZE, 1);

if (self->db) {

if (self->apsw_connection) {

ret = PyObject_CallMethod(self->apsw_connection, "close", "");

Py_XDECREF(ret);

Py_CLEAR(self->apsw_connection);

self->db = NULL;

} else {

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_INCREF(Py_None);

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

self->inTransaction = 1;

} else {

_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_INCREF(Py_None);

return Py_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 (self->inTransaction) {

Py_BEGIN_ALLOW_THREADS

rc = sqlite3_prepare(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) {

self->inTransaction = 0;

} else {

_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_INCREF(Py_None);

return Py_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 (self->inTransaction) {

pysqlite_do_all_statements(self, ACTION_RESET, 1);

Py_BEGIN_ALLOW_THREADS

rc = sqlite3_prepare(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) {

self->inTransaction = 0;

} else {

_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_INCREF(Py_None);

return Py_None;

}

}

static int

_pysqlite_set_result(sqlite3_context* context, PyObject* py_val)

{

if (py_val == Py_None) {

sqlite3_result_null(context);

} else if (PyInt_Check(py_val)) {

sqlite3_result_int64(context, (sqlite_int64)PyInt_AsLong(py_val));

} 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 (PyBuffer_Check(py_val)) {

const char* buffer;

Py_ssize_t buflen;

if (PyObject_AsCharBuffer(py_val, &buffer, &buflen) != 0) {

PyErr_SetString(PyExc_ValueError, "could not convert BLOB to buffer");

return -1;

}

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

PyObject * stringval = PyUnicode_AsUTF8String(py_val);

if (!stringval)

return -1;

sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT);

Py_DECREF(stringval);

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

void* raw_buffer;

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

}

break;

case SQLITE_BLOB:

buflen = sqlite3_value_bytes(cur_value);

cur_py_value = PyBuffer_New(buflen);

if (!cur_py_value) {

break;

}

if (PyObject_AsWriteBuffer(cur_py_value, &raw_buffer, &buflen)) {

Py_DECREF(cur_py_value);

cur_py_value = NULL;

break;

}

memcpy(raw_buffer, 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;

#ifdef WITH_THREAD

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

PyErr_Print();

} else {

PyErr_Clear();

}

_sqlite3_result_error(context, "user-defined function raised exception", -1);

}

#ifdef WITH_THREAD

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;

#ifdef WITH_THREAD

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

*aggregate_instance = PyObject_CallFunction(aggregate_class, "");

if (PyErr_Occurred()) {

*aggregate_instance = 0;

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

#ifdef WITH_THREAD

PyGILState_Release(threadstate);

}

void _pysqlite_final_callback(sqlite3_context* context)

{

PyObject* function_result;

PyObject** aggregate_instance;

int ok;

#ifdef WITH_THREAD

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;

}

function_result = PyObject_CallMethod(*aggregate_instance, "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 (_enable_callback_tracebacks) {

PyErr_Print();

} else {

PyErr_Clear();

}

_sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1);

}

error:

; /* necessary for --without-threads flag */

#ifdef WITH_THREAD

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", NULL, NULL};

PyObject* func;

char* name;

int narg;

int rc;

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

return NULL;

}

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO", kwlist,

&name, &narg, &func))

{

return NULL;

}

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

return NULL;

} else {

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

return NULL;

Py_INCREF(Py_None);

return Py_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_INCREF(Py_None);

return Py_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;

#ifdef WITH_THREAD

PyGILState_STATE gilstate;

gilstate = PyGILState_Ensure();

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

if (!ret) {

if (_enable_callback_tracebacks) {

PyErr_Print();

} else {

PyErr_Clear();

}

rc = SQLITE_DENY;

} else {

if (PyInt_Check(ret)) {

rc = _PyInt_AsInt(ret);

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

rc = SQLITE_DENY;

} else {

rc = SQLITE_DENY;

}

Py_DECREF(ret);

}

#ifdef WITH_THREAD

PyGILState_Release(gilstate);

return rc;

}

static int _progress_handler(void* user_arg)

{

int rc;

PyObject *ret;

#ifdef WITH_THREAD

PyGILState_STATE gilstate;

gilstate = PyGILState_Ensure();

ret = PyObject_CallFunction((PyObject*)user_arg, "");

if (!ret) {

if (_enable_callback_tracebacks) {

PyErr_Print();

} else {

PyErr_Clear();

}

/* abort query if error occurred */

rc = 1;

} else {

rc = (int)PyObject_IsTrue(ret);

Py_DECREF(ret);

}

#ifdef WITH_THREAD

PyGILState_Release(gilstate);

return rc;

}

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

{

PyObject* authorizer_cb;

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

int rc;