#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

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

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->begin_statement = NULL;

self->statement_cache = NULL;

self->statements = 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 a 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;

pysqlite_connection_set_isolation_level(self, isolation_level);

Py_DECREF(isolation_level);

self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements);

if (PyErr_Occurred()) {

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

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

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_DECREF(self->statement_cache);

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

PyObject* weakref;

PyObject* statement;

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

}

}

}

}

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

self->ob_type->tp_free((PyObject*)self);

}

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

{

static char *kwlist[] = {"factory", NULL, 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_CallFunction(factory, "O", self);

if (cursor && self->row_factory != Py_None) {

Py_XDECREF(((pysqlite_Cursor*)cursor)->row_factory);

Py_INCREF(self->row_factory);

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

if (self->db) {

if (self->apsw_connection) {

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

Py_XDECREF(ret);

Py_XDECREF(self->apsw_connection);

self->apsw_connection = NULL;

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

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;

}

}

void _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)

{

long longval;

const char* buffer;

Py_ssize_t buflen;

PyObject* stringval;

if ((!py_val) || PyErr_Occurred()) {

sqlite3_result_null(context);

} else if (py_val == Py_None) {

sqlite3_result_null(context);

} else if (PyInt_Check(py_val)) {

longval = PyInt_AsLong(py_val);

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

}

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

if (stringval) {

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

Py_DECREF(stringval);

}

} else {

/* TODO: raise error */

}

}

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_LONG_LONG val_int;

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:

val_int = sqlite3_value_int64(cur_value);

cur_py_value = PyInt_FromLong((long)val_int);

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;

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

}

if (py_retval) {

_pysqlite_set_result(context, py_retval);

Py_DECREF(py_retval);

} else {

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

PyGILState_Release(threadstate);

}

void _pysqlite_final_callback(sqlite3_context* context)

{

PyObject* function_result = NULL;

PyObject** aggregate_instance;

PyObject* aggregate_class;

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

/* this branch is executed if there was an exception in the aggregate's

goto error;

}

function_result = PyObject_CallMethod(*aggregate_instance, "finalize", "");

if (!function_result) {

if (_enable_callback_tracebacks) {

PyErr_Print();

} else {

PyErr_Clear();

}

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

} else {

_pysqlite_set_result(context, function_result);

}

error:

Py_XDECREF(*aggregate_instance);

Py_XDECREF(function_result);

PyGILState_Release(threadstate);

}

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_DECREF(self->statements);

self->statements = 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 (!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 {

PyDict_SetItem(self->function_pinboard, func, Py_None);

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

PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None);

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;

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 = (int)PyInt_AsLong(ret);

} 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_CallFunction((PyObject*)user_arg, "");

if (!ret) {

if (_enable_callback_tracebacks) {

PyErr_Print();

} else {

PyErr_Clear();

}

/* abort query if error occured */

rc = 1;

} else {

rc = (int)PyObject_IsTrue(ret);

Py_DECREF(ret);

}

PyGILState_Release(gilstate);

return rc;

}

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

{

PyObject* authorizer_cb;

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

int rc;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_authorizer",

kwlist, &authorizer_cb)) {

return NULL;

}

rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb);

if (rc != SQLITE_OK) {

PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback");

return NULL;

} else {

PyDict_SetItem(self->function_pinboard, authorizer_cb, Py_None);

Py_INCREF(Py_None);

return Py_None;

}

}

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

{

PyObject* progress_handler;

int n;

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

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi:set_progress_handler",

kwlist, &progress_handler, &n)) {

return NULL;

}

if (progress_handler == Py_None) {

/* None clears the progress handler previously set */

sqlite3_progress_handler(self->db, 0, 0, (void*)0);

} else {

sqlite3_progress_handler(self->db, n, _progress_handler, progress_handler);

PyDict_SetItem(self->function_pinboard, progress_handler, Py_None);

}

Py_INCREF(Py_None);

return Py_None;

}

int pysqlite_check_thread(pysqlite_Connection* self)

{

if (self->check_same_thread) {

if (PyThread_get_thread_ident() != self->thread_ident) {

PyErr_Format(pysqlite_ProgrammingError,

"SQLite objects created in a thread can only be used in that same thread."

"The object was created in thread id %ld and this is thread id %ld",

self->thread_ident, PyThread_get_thread_ident());

return 0;

}

}

return 1;

}

static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)

{

Py_INCREF(self->isolation_level);

return self->isolation_level;

}

static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)

{

if (!pysqlite_check_connection(self)) {

return NULL;

} else {

return Py_BuildValue("i", sqlite3_total_changes(self->db));

}

}

static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level)

{

PyObject* res;

PyObject* begin_statement;

char* begin_statement_str;

Py_XDECREF(self->isolation_level);

if (self->begin_statement) {

PyMem_Free(self->begin_statement);

self->begin_statement = NULL;

}

if (isolation_level == Py_None) {

Py_INCREF(Py_None);

self->isolation_level = Py_None;

res = pysqlite_connection_commit(self, NULL);

if (!res) {

return -1;

}

Py_DECREF(res);

self->inTransaction = 0;

} else {

Py_INCREF(isolation_level);

self->isolation_level = isolation_level;

begin_statement = PyString_FromString("BEGIN ");

if (!begin_statement) {

return -1;

}

PyString_Concat(&begin_statement, isolation_level);

if (!begin_statement) {

return -1;

}

begin_statement_str = PyString_AsString(begin_statement);

if (!begin_statement_str) {

Py_DECREF(begin_statement);

return -1;

}

self->begin_statement = PyMem_Malloc(strlen(begin_statement_str) + 2);

if (!self->begin_statement) {

Py_DECREF(begin_statement);

return -1;

}

strcpy(self->begin_statement, begin_statement_str);

Py_DECREF(begin_statement);

}

return 0;

}

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

{

PyObject* sql;

pysqlite_Statement* statement;

PyObject* weakref;

int rc;