1 /* connection.c - the connection type

     2  *

     3  * Copyright (C) 2004-2007 Gerhard Häring <gh@ghaering.de>

     4  *

     5  * This file is part of pysqlite.

     6  * 

     7  * This software is provided 'as-is', without any express or implied

     8  * warranty.  In no event will the authors be held liable for any damages

     9  * arising from the use of this software.

    10  *

    11  * Permission is granted to anyone to use this software for any purpose,

    12  * including commercial applications, and to alter it and redistribute it

    13  * freely, subject to the following restrictions:

    14  *

    15  * 1. The origin of this software must not be misrepresented; you must not

    16  *    claim that you wrote the original software. If you use this software

    17  *    in a product, an acknowledgment in the product documentation would be

    18  *    appreciated but is not required.

    19  * 2. Altered source versions must be plainly marked as such, and must not be

    20  *    misrepresented as being the original software.

    21  * 3. This notice may not be removed or altered from any source distribution.

    22  */

    23 

    24 #include "cache.h"

    25 #include "module.h"

    26 #include "connection.h"

    27 #include "statement.h"

    28 #include "cursor.h"

    29 #include "prepare_protocol.h"

    30 #include "util.h"

    31 #include "sqlitecompat.h"

    32 

    33 #include "pythread.h"

    34 

    35 #define ACTION_FINALIZE 1

    36 #define ACTION_RESET 2

    37 

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

    39 

    40 

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

    42 {

    43     /* in older SQLite versions, calling sqlite3_result_error in callbacks

    44      * triggers a bug in SQLite that leads either to irritating results or

    45      * segfaults, depending on the SQLite version */

    46 #if SQLITE_VERSION_NUMBER >= 3003003

    47     sqlite3_result_error(ctx, errmsg, len);

    48 #else

    49     PyErr_SetString(pysqlite_OperationalError, errmsg);

    50 #endif

    51 }

    52 

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

    54 {

    55     static char *kwlist[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", NULL, NULL};

    56 

    57     PyObject* database;

    58     int detect_types = 0;

    59     PyObject* isolation_level = NULL;

    60     PyObject* factory = NULL;

    61     int check_same_thread = 1;

    62     int cached_statements = 100;

    63     double timeout = 5.0;

    64     int rc;

    65     PyObject* class_attr = NULL;

    66     PyObject* class_attr_str = NULL;

    67     int is_apsw_connection = 0;

    68     PyObject* database_utf8;

    69 

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

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

    72     {

    73         return -1;

    74     }

    75 

    76     self->begin_statement = NULL;

    77 

    78     self->statement_cache = NULL;

    79     self->statements = NULL;

    80 

    81     Py_INCREF(Py_None);

    82     self->row_factory = Py_None;

    83 

    84     Py_INCREF(&PyUnicode_Type);

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

    86 

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

    88         if (PyString_Check(database)) {

    89             database_utf8 = database;

    90             Py_INCREF(database_utf8);

    91         } else {

    92             database_utf8 = PyUnicode_AsUTF8String(database);

    93             if (!database_utf8) {

    94                 return -1;

    95             }

    96         }

    97 

    98         Py_BEGIN_ALLOW_THREADS

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

   100         Py_END_ALLOW_THREADS

   101 

   102         Py_DECREF(database_utf8);

   103 

   104         if (rc != SQLITE_OK) {

   105             _pysqlite_seterror(self->db, NULL);

   106             return -1;

   107         }

   108     } else {

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

   110         class_attr = PyObject_GetAttrString(database, "__class__");

   111         if (class_attr) {

   112             class_attr_str = PyObject_Str(class_attr);

   113             if (class_attr_str) {

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

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

   116                      * PyObject_HEAD is the sqlite3* we want to get hold of.

   117                      * Luckily, this is the same layout as we have in our

   118                      * pysqlite_Connection */

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

   120 

   121                     Py_INCREF(database);

   122                     self->apsw_connection = database;

   123                     is_apsw_connection = 1;

   124                 }

   125             }

   126         }

   127         Py_XDECREF(class_attr_str);

   128         Py_XDECREF(class_attr);

   129 

   130         if (!is_apsw_connection) {

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

   132             return -1;

   133         }

   134     }

   135 

   136     if (!isolation_level) {

   137         isolation_level = PyString_FromString("");

   138         if (!isolation_level) {

   139             return -1;

   140         }

   141     } else {

   142         Py_INCREF(isolation_level);

   143     }

   144     self->isolation_level = NULL;

   145     pysqlite_connection_set_isolation_level(self, isolation_level);

   146     Py_DECREF(isolation_level);

   147 

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

   149     if (PyErr_Occurred()) {

   150         return -1;

   151     }

   152 

   153     self->statements = PyList_New(0);

   154     if (!self->statements) {

   155         return -1;

   156     }

   157     self->created_statements = 0;

   158 

   159     /* By default, the Cache class INCREFs the factory in its initializer, and

   160      * decrefs it in its deallocator method. Since this would create a circular

   161      * reference here, we're breaking it by decrementing self, and telling the

   162      * cache class to not decref the factory (self) in its deallocator.

   163      */

   164     self->statement_cache->decref_factory = 0;

   165     Py_DECREF(self);

   166 

   167     self->inTransaction = 0;

   168     self->detect_types = detect_types;

   169     self->timeout = timeout;

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

   171 

   172     self->thread_ident = PyThread_get_thread_ident();

   173     self->check_same_thread = check_same_thread;

   174 

   175     self->function_pinboard = PyDict_New();

   176     if (!self->function_pinboard) {

   177         return -1;

   178     }

   179 

   180     self->collations = PyDict_New();

   181     if (!self->collations) {

   182         return -1;

   183     }

   184 

   185     self->Warning               = pysqlite_Warning;

   186     self->Error                 = pysqlite_Error;

   187     self->InterfaceError        = pysqlite_InterfaceError;

   188     self->DatabaseError         = pysqlite_DatabaseError;

   189     self->DataError             = pysqlite_DataError;

   190     self->OperationalError      = pysqlite_OperationalError;

   191     self->IntegrityError        = pysqlite_IntegrityError;

   192     self->InternalError         = pysqlite_InternalError;

   193     self->ProgrammingError      = pysqlite_ProgrammingError;

   194     self->NotSupportedError     = pysqlite_NotSupportedError;

   195 

   196     return 0;

   197 }

   198 

   199 /* Empty the entire statement cache of this connection */

   200 void pysqlite_flush_statement_cache(pysqlite_Connection* self)

   201 {

   202     pysqlite_Node* node;

   203     pysqlite_Statement* statement;

   204 

   205     node = self->statement_cache->first;

   206 

   207     while (node) {

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

   209         (void)pysqlite_statement_finalize(statement);

   210         node = node->next;

   211     }

   212 

   213     Py_DECREF(self->statement_cache);

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

   215     Py_DECREF(self);

   216     self->statement_cache->decref_factory = 0;

   217 }

   218 

   219 /* action in (ACTION_RESET, ACTION_FINALIZE) */

   220 void pysqlite_do_all_statements(pysqlite_Connection* self, int action)

   221 {

   222     int i;

   223     PyObject* weakref;

   224     PyObject* statement;

   225 

   226     for (i = 0; i < PyList_Size(self->statements); i++) {

   227         weakref = PyList_GetItem(self->statements, i);

   228         statement = PyWeakref_GetObject(weakref);

   229         if (statement != Py_None) {

   230             if (action == ACTION_RESET) {

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

   232             } else {

   233                 (void)pysqlite_statement_finalize((pysqlite_Statement*)statement);

   234             }

   235         }

   236     }

   237 }

   238 

   239 void pysqlite_connection_dealloc(pysqlite_Connection* self)

   240 {

   241     PyObject* ret = NULL;

   242 

   243     Py_XDECREF(self->statement_cache);

   244 

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

   246     if (self->db) {

   247         Py_BEGIN_ALLOW_THREADS

   248         sqlite3_close(self->db);

   249         Py_END_ALLOW_THREADS

   250     } else if (self->apsw_connection) {

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

   252         Py_XDECREF(ret);

   253         Py_XDECREF(self->apsw_connection);

   254     }

   255 

   256     if (self->begin_statement) {

   257         PyMem_Free(self->begin_statement);

   258     }

   259     Py_XDECREF(self->isolation_level);

   260     Py_XDECREF(self->function_pinboard);

   261     Py_XDECREF(self->row_factory);

   262     Py_XDECREF(self->text_factory);

   263     Py_XDECREF(self->collations);

   264     Py_XDECREF(self->statements);

   265 

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

   267 }

   268 

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

   270 {

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

   272     PyObject* factory = NULL;

   273     PyObject* cursor;

   274 

   275 

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

   277                                      &factory)) {

   278         return NULL;

   279     }

   280 

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

   282         return NULL;

   283     }

   284 

   285     if (factory == NULL) {

   286         factory = (PyObject*)&pysqlite_CursorType;

   287     }

   288 

   289     cursor = PyObject_CallFunction(factory, "O", self);

   290 

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

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

   293         Py_INCREF(self->row_factory);

   294         ((pysqlite_Cursor*)cursor)->row_factory = self->row_factory;

   295     }

   296 

   297     return cursor;

   298 }

   299 

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

   301 {

   302     PyObject* ret;

   303     int rc;

   304 

   305     if (!pysqlite_check_thread(self)) {

   306         return NULL;

   307     }

   308 

   309     pysqlite_do_all_statements(self, ACTION_FINALIZE);

   310 

   311     if (self->db) {

   312         if (self->apsw_connection) {

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

   314             Py_XDECREF(ret);

   315             Py_XDECREF(self->apsw_connection);

   316             self->apsw_connection = NULL;

   317             self->db = NULL;

   318         } else {

   319             Py_BEGIN_ALLOW_THREADS

   320             rc = sqlite3_close(self->db);

   321             Py_END_ALLOW_THREADS

   322 

   323             if (rc != SQLITE_OK) {

   324                 _pysqlite_seterror(self->db, NULL);

   325                 return NULL;

   326             } else {

   327                 self->db = NULL;

   328             }

   329         }

   330     }

   331 

   332     Py_INCREF(Py_None);

   333     return Py_None;

   334 }

   335 

   336 /*

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

   338  *

   339  * 0 => error; 1 => ok

   340  */

   341 int pysqlite_check_connection(pysqlite_Connection* con)

   342 {

   343     if (!con->db) {

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

   345         return 0;

   346     } else {

   347         return 1;

   348     }

   349 }

   350 

   351 PyObject* _pysqlite_connection_begin(pysqlite_Connection* self)

   352 {

   353     int rc;

   354     const char* tail;

   355     sqlite3_stmt* statement;

   356 

   357     Py_BEGIN_ALLOW_THREADS

   358     rc = sqlite3_prepare(self->db, self->begin_statement, -1, &statement, &tail);

   359     Py_END_ALLOW_THREADS

   360 

   361     if (rc != SQLITE_OK) {

   362         _pysqlite_seterror(self->db, statement);

   363         goto error;

   364     }

   365 

   366     rc = pysqlite_step(statement, self);

   367     if (rc == SQLITE_DONE) {

   368         self->inTransaction = 1;

   369     } else {

   370         _pysqlite_seterror(self->db, statement);

   371     }

   372 

   373     Py_BEGIN_ALLOW_THREADS

   374     rc = sqlite3_finalize(statement);

   375     Py_END_ALLOW_THREADS

   376 

   377     if (rc != SQLITE_OK && !PyErr_Occurred()) {

   378         _pysqlite_seterror(self->db, NULL);

   379     }

   380 

   381 error:

   382     if (PyErr_Occurred()) {

   383         return NULL;

   384     } else {

   385         Py_INCREF(Py_None);

   386         return Py_None;

   387     }

   388 }

   389 

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

   391 {

   392     int rc;

   393     const char* tail;

   394     sqlite3_stmt* statement;

   395 

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

   397         return NULL;

   398     }

   399 

   400     if (self->inTransaction) {

   401         Py_BEGIN_ALLOW_THREADS

   402         rc = sqlite3_prepare(self->db, "COMMIT", -1, &statement, &tail);

   403         Py_END_ALLOW_THREADS

   404         if (rc != SQLITE_OK) {

   405             _pysqlite_seterror(self->db, NULL);

   406             goto error;

   407         }

   408 

   409         rc = pysqlite_step(statement, self);

   410         if (rc == SQLITE_DONE) {

   411             self->inTransaction = 0;

   412         } else {

   413             _pysqlite_seterror(self->db, statement);

   414         }

   415 

   416         Py_BEGIN_ALLOW_THREADS

   417         rc = sqlite3_finalize(statement);

   418         Py_END_ALLOW_THREADS

   419         if (rc != SQLITE_OK && !PyErr_Occurred()) {

   420             _pysqlite_seterror(self->db, NULL);

   421         }

   422 

   423     }

   424 

   425 error:

   426     if (PyErr_Occurred()) {

   427         return NULL;

   428     } else {

   429         Py_INCREF(Py_None);

   430         return Py_None;

   431     }

   432 }

   433 

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

   435 {

   436     int rc;

   437     const char* tail;

   438     sqlite3_stmt* statement;

   439 

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

   441         return NULL;

   442     }

   443 

   444     if (self->inTransaction) {

   445         pysqlite_do_all_statements(self, ACTION_RESET);

   446 

   447         Py_BEGIN_ALLOW_THREADS

   448         rc = sqlite3_prepare(self->db, "ROLLBACK", -1, &statement, &tail);

   449         Py_END_ALLOW_THREADS

   450         if (rc != SQLITE_OK) {

   451             _pysqlite_seterror(self->db, NULL);

   452             goto error;

   453         }

   454 

   455         rc = pysqlite_step(statement, self);

   456         if (rc == SQLITE_DONE) {

   457             self->inTransaction = 0;

   458         } else {

   459             _pysqlite_seterror(self->db, statement);

   460         }

   461 

   462         Py_BEGIN_ALLOW_THREADS

   463         rc = sqlite3_finalize(statement);

   464         Py_END_ALLOW_THREADS

   465         if (rc != SQLITE_OK && !PyErr_Occurred()) {

   466             _pysqlite_seterror(self->db, NULL);

   467         }

   468 

   469     }

   470 

   471 error:

   472     if (PyErr_Occurred()) {

   473         return NULL;

   474     } else {

   475         Py_INCREF(Py_None);

   476         return Py_None;

   477     }

   478 }

   479 

   480 void _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)

   481 {

   482     long longval;

   483     const char* buffer;

   484     Py_ssize_t buflen;

   485     PyObject* stringval;

   486 

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

   488         sqlite3_result_null(context);

   489     } else if (py_val == Py_None) {

   490         sqlite3_result_null(context);

   491     } else if (PyInt_Check(py_val)) {

   492         longval = PyInt_AsLong(py_val);

   493         sqlite3_result_int64(context, (PY_LONG_LONG)longval);

   494     } else if (PyFloat_Check(py_val)) {

   495         sqlite3_result_double(context, PyFloat_AsDouble(py_val));

   496     } else if (PyBuffer_Check(py_val)) {

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

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

   499         } else {

   500             sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT);

   501         }

   502     } else if (PyString_Check(py_val)) {

   503         sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT);

   504     } else if (PyUnicode_Check(py_val)) {

   505         stringval = PyUnicode_AsUTF8String(py_val);

   506         if (stringval) {

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

   508             Py_DECREF(stringval);

   509         }

   510     } else {

   511         /* TODO: raise error */

   512     }

   513 }

   514 

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

   516 {

   517     PyObject* args;

   518     int i;

   519     sqlite3_value* cur_value;

   520     PyObject* cur_py_value;

   521     const char* val_str;

   522     PY_LONG_LONG val_int;

   523     Py_ssize_t buflen;

   524     void* raw_buffer;

   525 

   526     args = PyTuple_New(argc);

   527     if (!args) {

   528         return NULL;

   529     }

   530 

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

   532         cur_value = argv[i];

   533         switch (sqlite3_value_type(argv[i])) {

   534             case SQLITE_INTEGER:

   535                 val_int = sqlite3_value_int64(cur_value);

   536                 cur_py_value = PyInt_FromLong((long)val_int);

   537                 break;

   538             case SQLITE_FLOAT:

   539                 cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));

   540                 break;

   541             case SQLITE_TEXT:

   542                 val_str = (const char*)sqlite3_value_text(cur_value);

   543                 cur_py_value = PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);

   544                 /* TODO: have a way to show errors here */

   545                 if (!cur_py_value) {

   546                     PyErr_Clear();

   547                     Py_INCREF(Py_None);

   548                     cur_py_value = Py_None;

   549                 }

   550                 break;

   551             case SQLITE_BLOB:

   552                 buflen = sqlite3_value_bytes(cur_value);

   553                 cur_py_value = PyBuffer_New(buflen);

   554                 if (!cur_py_value) {

   555                     break;

   556                 }

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

   558                     Py_DECREF(cur_py_value);

   559                     cur_py_value = NULL;

   560                     break;

   561                 }

   562                 memcpy(raw_buffer, sqlite3_value_blob(cur_value), buflen);

   563                 break;

   564             case SQLITE_NULL:

   565             default:

   566                 Py_INCREF(Py_None);

   567                 cur_py_value = Py_None;

   568         }

   569 

   570         if (!cur_py_value) {

   571             Py_DECREF(args);

   572             return NULL;

   573         }

   574 

   575         PyTuple_SetItem(args, i, cur_py_value);

   576 

   577     }

   578 

   579     return args;

   580 }

   581 

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

   583 {

   584     PyObject* args;

   585     PyObject* py_func;

   586     PyObject* py_retval = NULL;

   587 

   588     PyGILState_STATE threadstate;

   589 

   590     threadstate = PyGILState_Ensure();

   591 

   592     py_func = (PyObject*)sqlite3_user_data(context);

   593 

   594     args = _pysqlite_build_py_params(context, argc, argv);

   595     if (args) {

   596         py_retval = PyObject_CallObject(py_func, args);

   597         Py_DECREF(args);

   598     }

   599 

   600     if (py_retval) {

   601         _pysqlite_set_result(context, py_retval);

   602         Py_DECREF(py_retval);

   603     } else {

   604         if (_enable_callback_tracebacks) {

   605             PyErr_Print();

   606         } else {

   607             PyErr_Clear();

   608         }

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

   610     }

   611 

   612     PyGILState_Release(threadstate);

   613 }

   614 

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

   616 {

   617     PyObject* args;

   618     PyObject* function_result = NULL;

   619     PyObject* aggregate_class;

   620     PyObject** aggregate_instance;

   621     PyObject* stepmethod = NULL;

   622 

   623     PyGILState_STATE threadstate;

   624 

   625     threadstate = PyGILState_Ensure();

   626 

   627     aggregate_class = (PyObject*)sqlite3_user_data(context);

   628 

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

   630 

   631     if (*aggregate_instance == 0) {

   632         *aggregate_instance = PyObject_CallFunction(aggregate_class, "");

   633 

   634         if (PyErr_Occurred()) {

   635             *aggregate_instance = 0;

   636             if (_enable_callback_tracebacks) {

   637                 PyErr_Print();

   638             } else {

   639                 PyErr_Clear();

   640             }

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

   642             goto error;

   643         }

   644     }

   645 

   646     stepmethod = PyObject_GetAttrString(*aggregate_instance, "step");

   647     if (!stepmethod) {

   648         goto error;

   649     }

   650 

   651     args = _pysqlite_build_py_params(context, argc, params);

   652     if (!args) {

   653         goto error;

   654     }

   655 

   656     function_result = PyObject_CallObject(stepmethod, args);

   657     Py_DECREF(args);

   658 

   659     if (!function_result) {

   660         if (_enable_callback_tracebacks) {

   661             PyErr_Print();

   662         } else {

   663             PyErr_Clear();

   664         }

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

   666     }

   667 

   668 error:

   669     Py_XDECREF(stepmethod);

   670     Py_XDECREF(function_result);

   671 

   672     PyGILState_Release(threadstate);

   673 }

   674 

   675 void _pysqlite_final_callback(sqlite3_context* context)

   676 {

   677     PyObject* function_result = NULL;

   678     PyObject** aggregate_instance;

   679     PyObject* aggregate_class;

   680 

   681     PyGILState_STATE threadstate;

   682 

   683     threadstate = PyGILState_Ensure();

   684 

   685     aggregate_class = (PyObject*)sqlite3_user_data(context);

   686 

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

   688     if (!*aggregate_instance) {

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

   690          * __init__ */

   691 

   692         goto error;

   693     }

   694 

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

   696     if (!function_result) {

   697         if (_enable_callback_tracebacks) {

   698             PyErr_Print();

   699         } else {

   700             PyErr_Clear();

   701         }

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

   703     } else {

   704         _pysqlite_set_result(context, function_result);

   705     }

   706 

   707 error:

   708     Py_XDECREF(*aggregate_instance);

   709     Py_XDECREF(function_result);

   710 

   711     PyGILState_Release(threadstate);

   712 }

   713 

   714 void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self)

   715 {

   716     PyObject* new_list;

   717     PyObject* weakref;

   718     int i;

   719 

   720     /* we only need to do this once in a while */

   721     if (self->created_statements++ < 200) {

   722         return;

   723     }

   724 

   725     self->created_statements = 0;

   726 

   727     new_list = PyList_New(0);

   728     if (!new_list) {

   729         return;

   730     }

   731 

   732     for (i = 0; i < PyList_Size(self->statements); i++) {

   733         weakref = PyList_GetItem(self->statements, i);

   734         if (PyWeakref_GetObject(weakref) != Py_None) {

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

   736                 Py_DECREF(new_list);

   737                 return;

   738             }

   739         }

   740     }

   741 

   742     Py_DECREF(self->statements);

   743     self->statements = new_list;

   744 }

   745 

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

   747 {

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

   749 

   750     PyObject* func;

   751     char* name;

   752     int narg;

   753     int rc;

   754 

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

   756                                      &name, &narg, &func))

   757     {

   758         return NULL;

   759     }

   760 

   761     rc = sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _pysqlite_func_callback, NULL, NULL);

   762 

   763     if (rc != SQLITE_OK) {

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

   765         PyErr_SetString(pysqlite_OperationalError, "Error creating function");

   766         return NULL;

   767     } else {

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

   769 

   770         Py_INCREF(Py_None);

   771         return Py_None;

   772     }

   773 }

   774 

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

   776 {

   777     PyObject* aggregate_class;

   778 

   779     int n_arg;

   780     char* name;

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

   782     int rc;

   783 

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

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

   786         return NULL;

   787     }

   788 

   789     rc = sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_pysqlite_step_callback, &_pysqlite_final_callback);

   790     if (rc != SQLITE_OK) {

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

   792         PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");

   793         return NULL;

   794     } else {

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

   796 

   797         Py_INCREF(Py_None);

   798         return Py_None;

   799     }

   800 }

   801 

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

   803 {

   804     PyObject *ret;

   805     int rc;

   806     PyGILState_STATE gilstate;

   807 

   808     gilstate = PyGILState_Ensure();

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

   810 

   811     if (!ret) {

   812         if (_enable_callback_tracebacks) {

   813             PyErr_Print();

   814         } else {

   815             PyErr_Clear();

   816         }

   817 

   818         rc = SQLITE_DENY;

   819     } else {

   820         if (PyInt_Check(ret)) {

   821             rc = (int)PyInt_AsLong(ret);

   822         } else {

   823             rc = SQLITE_DENY;

   824         }

   825         Py_DECREF(ret);

   826     }

   827 

   828     PyGILState_Release(gilstate);

   829     return rc;

   830 }

   831 

   832 static int _progress_handler(void* user_arg)

   833 {

   834     int rc;

   835     PyObject *ret;

   836     PyGILState_STATE gilstate;

   837 

   838     gilstate = PyGILState_Ensure();

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

   840 

   841     if (!ret) {

   842         if (_enable_callback_tracebacks) {

   843             PyErr_Print();

   844         } else {

   845             PyErr_Clear();

   846         }

   847 

   848         /* abort query if error occured */

   849         rc = 1; 

   850     } else {

   851         rc = (int)PyObject_IsTrue(ret);

   852         Py_DECREF(ret);

   853     }

   854 

   855     PyGILState_Release(gilstate);

   856     return rc;

   857 }

   858 

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

   860 {

   861     PyObject* authorizer_cb;

   862 

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

   864     int rc;

   865 

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

   867                                       kwlist, &authorizer_cb)) {

   868         return NULL;

   869     }

   870 

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

   872 

   873     if (rc != SQLITE_OK) {

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

   875         return NULL;

   876     } else {

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

   878 

   879         Py_INCREF(Py_None);

   880         return Py_None;

   881     }

   882 }

   883 

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

   885 {

   886     PyObject* progress_handler;

   887     int n;

   888 

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

   890 

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

   892                                       kwlist, &progress_handler, &n)) {

   893         return NULL;

   894     }

   895 

   896     if (progress_handler == Py_None) {

   897         /* None clears the progress handler previously set */

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

   899     } else {

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

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

   902     }

   903 

   904     Py_INCREF(Py_None);

   905     return Py_None;

   906 }

   907 

   908 int pysqlite_check_thread(pysqlite_Connection* self)

   909 {

   910     if (self->check_same_thread) {

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

   912             PyErr_Format(pysqlite_ProgrammingError,

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

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

   915                         self->thread_ident, PyThread_get_thread_ident());

   916             return 0;

   917         }

   918 

   919     }

   920 

   921     return 1;

   922 }

   923 

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

   925 {

   926     Py_INCREF(self->isolation_level);

   927     return self->isolation_level;

   928 }

   929 

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

   931 {

   932     if (!pysqlite_check_connection(self)) {

   933         return NULL;

   934     } else {

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

   936     }

   937 }

   938 

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

   940 {

   941     PyObject* res;

   942     PyObject* begin_statement;

   943     char* begin_statement_str;

   944 

   945     Py_XDECREF(self->isolation_level);

   946 

   947     if (self->begin_statement) {

   948         PyMem_Free(self->begin_statement);

   949         self->begin_statement = NULL;

   950     }

   951 

   952     if (isolation_level == Py_None) {

   953         Py_INCREF(Py_None);

   954         self->isolation_level = Py_None;

   955 

   956         res = pysqlite_connection_commit(self, NULL);

   957         if (!res) {

   958             return -1;

   959         }

   960         Py_DECREF(res);

   961 

   962         self->inTransaction = 0;

   963     } else {

   964         Py_INCREF(isolation_level);

   965         self->isolation_level = isolation_level;

   966 

   967         begin_statement = PyString_FromString("BEGIN ");

   968         if (!begin_statement) {

   969             return -1;

   970         }

   971         PyString_Concat(&begin_statement, isolation_level);

   972         if (!begin_statement) {

   973             return -1;

   974         }

   975 

   976         begin_statement_str = PyString_AsString(begin_statement);

   977         if (!begin_statement_str) {

   978             Py_DECREF(begin_statement);

   979             return -1;

   980         }

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

   982         if (!self->begin_statement) {

   983             Py_DECREF(begin_statement);

   984             return -1;

   985         }

   986 

   987         strcpy(self->begin_statement, begin_statement_str);

   988         Py_DECREF(begin_statement);

   989     }

   990 

   991     return 0;

   992 }

   993 

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

   995 {

   996     PyObject* sql;

   997     pysqlite_Statement* statement;

   998     PyObject* weakref;

   999     int rc;

  1000 

  1001     if (!PyArg_ParseTuple(args, "O", &sql)) {

  1002         return NULL;

  1003     }

  1004 

  1005     _pysqlite_drop_unused_statement_references(self);

  1006 

  1007     statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType);

  1008     if (!statement) {

  1009         return NULL;

  1010     }

  1011 

  1012     rc = pysqlite_statement_create(statement, self, sql);

  1013 

  1014     if (rc != SQLITE_OK) {

  1015         if (rc == PYSQLITE_TOO_MUCH_SQL) {

  1016             PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time.");

  1017         } else if (rc == PYSQLITE_SQL_WRONG_TYPE) {

  1018             PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string or unicode.");

  1019         } else {

  1020             (void)pysqlite_statement_reset(statement);

  1021             _pysqlite_seterror(self->db, NULL);

  1022         }

  1023 

  1024         Py_CLEAR(statement);

  1025     } else {

  1026         weakref = PyWeakref_NewRef((PyObject*)statement, NULL);

  1027         if (!weakref) {

  1028             Py_CLEAR(statement);

  1029             goto error;

  1030         }

  1031 

  1032         if (PyList_Append(self->statements, weakref) != 0) {

  1033             Py_CLEAR(weakref);

  1034             goto error;

  1035         }

  1036 

  1037         Py_DECREF(weakref);

  1038     }

  1039 

  1040 error:

  1041     return (PyObject*)statement;

  1042 }

  1043 

  1044 PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

  1045 {

  1046     PyObject* cursor = 0;

  1047     PyObject* result = 0;

  1048     PyObject* method = 0;

  1049 

  1050     cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");

  1051     if (!cursor) {

  1052         goto error;

  1053     }

  1054 

  1055     method = PyObject_GetAttrString(cursor, "execute");

  1056     if (!method) {

  1057         Py_CLEAR(cursor);

  1058         goto error;

  1059     }

  1060 

  1061     result = PyObject_CallObject(method, args);

  1062     if (!result) {

  1063         Py_CLEAR(cursor);

  1064     }

  1065 

  1066 error:

  1067     Py_XDECREF(result);

  1068     Py_XDECREF(method);

  1069 

  1070     return cursor;

  1071 }

  1072 

  1073 PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

  1074 {

  1075     PyObject* cursor = 0;

  1076     PyObject* result = 0;

  1077     PyObject* method = 0;

  1078 

  1079     cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");

  1080     if (!cursor) {

  1081         goto error;

  1082     }

  1083 

  1084     method = PyObject_GetAttrString(cursor, "executemany");

  1085     if (!method) {

  1086         Py_CLEAR(cursor);

  1087         goto error;

  1088     }

  1089 

  1090     result = PyObject_CallObject(method, args);

  1091     if (!result) {

  1092         Py_CLEAR(cursor);

  1093     }

  1094 

  1095 error:

  1096     Py_XDECREF(result);

  1097     Py_XDECREF(method);

  1098 

  1099     return cursor;

  1100 }

  1101 

  1102 PyObject* pysqlite_connection_executescript(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)

  1103 {

  1104     PyObject* cursor = 0;

  1105     PyObject* result = 0;

  1106     PyObject* method = 0;

  1107 

  1108     cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");

  1109     if (!cursor) {

  1110         goto error;

  1111     }

  1112 

  1113     method = PyObject_GetAttrString(cursor, "executescript");

  1114     if (!method) {

  1115         Py_CLEAR(cursor);

  1116         goto error;

  1117     }

  1118 

  1119     result = PyObject_CallObject(method, args);

  1120     if (!result) {

  1121         Py_CLEAR(cursor);

  1122     }

  1123 

  1124 error:

  1125     Py_XDECREF(result);

  1126     Py_XDECREF(method);

  1127 

  1128     return cursor;

  1129 }

  1130 

  1131 /* ------------------------- COLLATION CODE ------------------------ */

  1132 

  1133 static int

  1134 pysqlite_collation_callback(

  1135         void* context,