Modules/_sqlite/connection.c

   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 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 = _sqlite_step_with_busyhandler(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 = _sqlite_step_with_busyhandler(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 = _sqlite_step_with_busyhandler(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
 944     Py_XDECREF(self->isolation_level);
 945
 946     if (self->begin_statement) {
 947         PyMem_Free(self->begin_statement);
 948         self->begin_statement = NULL;
 949     }
 950
 951     if (isolation_level == Py_None) {
 952         Py_INCREF(Py_None);
 953         self->isolation_level = Py_None;
 954
 955         res = pysqlite_connection_commit(self, NULL);
 956         if (!res) {
 957             return -1;
 958         }
 959         Py_DECREF(res);
 960
 961         self->inTransaction = 0;
 962     } else {
 963         Py_INCREF(isolation_level);
 964         self->isolation_level = isolation_level;
 965
 966         begin_statement = PyString_FromString("BEGIN ");
 967         if (!begin_statement) {
 968             return -1;
 969         }
 970         PyString_Concat(&begin_statement, isolation_level);
 971         if (!begin_statement) {
 972             return -1;
 973         }
 974
 975         self->begin_statement = PyMem_Malloc(PyString_Size(begin_statement) + 2);
 976         if (!self->begin_statement) {
 977             return -1;
 978         }
 979
 980         strcpy(self->begin_statement, PyString_AsString(begin_statement));
 981         Py_DECREF(begin_statement);
 982     }
 983
 984     return 0;
 985 }
 986
 987 PyObject* pysqlite_connection_call(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
 988 {
 989     PyObject* sql;
 990     pysqlite_Statement* statement;
 991     PyObject* weakref;
 992     int rc;
 993
 994     if (!PyArg_ParseTuple(args, "O", &sql)) {
 995         return NULL;
 996     }
 997
 998     _pysqlite_drop_unused_statement_references(self);
 999
1000     statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType);
1001     if (!statement) {
1002         return NULL;
1003     }
1004
1005     rc = pysqlite_statement_create(statement, self, sql);
1006
1007     if (rc != SQLITE_OK) {
1008         if (rc == PYSQLITE_TOO_MUCH_SQL) {
1009             PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time.");
1010         } else if (rc == PYSQLITE_SQL_WRONG_TYPE) {
1011             PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string or unicode.");
1012         } else {
1013             (void)pysqlite_statement_reset(statement);
1014             _pysqlite_seterror(self->db, NULL);
1015         }
1016
1017         Py_DECREF(statement);
1018         statement = 0;
1019     } else {
1020         weakref = PyWeakref_NewRef((PyObject*)statement, NULL);
1021         if (!weakref) {
1022             Py_DECREF(statement);
1023             statement = 0;
1024             goto error;
1025         }
1026
1027         if (PyList_Append(self->statements, weakref) != 0) {
1028             Py_DECREF(weakref);
1029             statement = 0;
1030             goto error;
1031         }
1032
1033         Py_DECREF(weakref);
1034     }
1035
1036 error:
1037     return (PyObject*)statement;
1038 }
1039
1040 PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
1041 {
1042     PyObject* cursor = 0;
1043     PyObject* result = 0;
1044     PyObject* method = 0;
1045
1046     cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
1047     if (!cursor) {
1048         goto error;
1049     }
1050
1051     method = PyObject_GetAttrString(cursor, "execute");
1052     if (!method) {
1053         Py_DECREF(cursor);
1054         cursor = 0;
1055         goto error;
1056     }
1057
1058     result = PyObject_CallObject(method, args);
1059     if (!result) {
1060         Py_DECREF(cursor);
1061         cursor = 0;
1062     }
1063
1064 error:
1065     Py_XDECREF(result);
1066     Py_XDECREF(method);
1067
1068     return cursor;
1069 }
1070
1071 PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
1072 {
1073     PyObject* cursor = 0;
1074     PyObject* result = 0;
1075     PyObject* method = 0;
1076
1077     cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
1078     if (!cursor) {
1079         goto error;
1080     }
1081
1082     method = PyObject_GetAttrString(cursor, "executemany");
1083     if (!method) {
1084         Py_DECREF(cursor);
1085         cursor = 0;
1086         goto error;
1087     }
1088
1089     result = PyObject_CallObject(method, args);
1090     if (!result) {
1091         Py_DECREF(cursor);
1092         cursor = 0;
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_DECREF(cursor);
1116         cursor = 0;
1117         goto error;
1118     }
1119
1120     result = PyObject_CallObject(method, args);
1121     if (!result) {
1122         Py_DECREF(cursor);
1123         cursor = 0;
1124     }
1125
1126 error:
1127     Py_XDECREF(result);
1128     Py_XDECREF(method);
1129
1130     return cursor;
1131 }
1132
1133 /* ------------------------- COLLATION CODE ------------------------ */
1134
1135 static int
1136 pysqlite_collation_callback(
1137         void* context,
1138         int text1_length, const void* text1_data,
1139         int text2_length, const void* text2_data)
1140 {
1141     PyObject* callback = (PyObject*)context;
1142     PyObject* string1 = 0;
1143     PyObject* string2 = 0;
1144     PyGILState_STATE gilstate;
1145
1146     PyObject* retval = NULL;
1147     int result = 0;
1148
1149     gilstate = PyGILState_Ensure();
1150
1151     if (PyErr_Occurred()) {
1152         goto finally;
1153     }
1154
1155     string1 = PyString_FromStringAndSize((const char*)text1_data, text1_length);
1156     string2 = PyString_FromStringAndSize((const char*)text2_data, text2_length);
1157
1158     if (!string1 || !string2) {
1159         goto finally; /* failed to allocate strings */
1160     }
1161
1162     retval = PyObject_CallFunctionObjArgs(callback, string1, string2, NULL);
1163
1164     if (!retval) {
1165         /* execution failed */
1166         goto finally;
1167     }
1168
1169     result = PyInt_AsLong(retval);
1170     if (PyErr_Occurred()) {
1171         result = 0;
1172     }
1173
1174 finally:
1175     Py_XDECREF(string1);
1176     Py_XDECREF(string2);
1177     Py_XDECREF(retval);
1178
1179     PyGILState_Release(gilstate);
1180
1181     return result;
1182 }
1183
1184 static PyObject *
1185 pysqlite_connection_interrupt(pysqlite_Connection* self, PyObject* args)
1186 {
1187     PyObject* retval = NULL;
1188
1189     if (!pysqlite_check_connection(self)) {
1190         goto finally;
1191     }
1192
1193     sqlite3_interrupt(self->db);
1194
1195     Py_INCREF(Py_None);
1196     retval = Py_None;
1197
1198 finally:
1199     return retval;
1200 }
1201
1202 /* Function author: Paul Kippes <kippesp@gmail.com>
1203  * Class method of Connection to call the Python function _iterdump
1204  * of the sqlite3 module.
1205  */
1206 static PyObject *
1207 pysqlite_connection_iterdump(pysqlite_Connection* self, PyObject* args)
1208 {
1209     PyObject* retval = NULL;
1210     PyObject* module = NULL;
1211     PyObject* module_dict;
1212     PyObject* pyfn_iterdump;
1213
1214     if (!pysqlite_check_connection(self)) {
1215         goto finally;
1216     }
1217
1218     module = PyImport_ImportModule(MODULE_NAME ".dump");
1219     if (!module) {
1220         goto finally;
1221     }
1222
1223     module_dict = PyModule_GetDict(module);
1224     if (!module_dict) {
1225         goto finally;
1226     }
1227
1228     pyfn_iterdump = PyDict_GetItemString(module_dict, "_iterdump");
1229     if (!pyfn_iterdump) {
1230         PyErr_SetString(pysqlite_OperationalError, "Failed to obtain _iterdump() reference");
1231         goto finally;
1232     }
1233
1234     args = PyTuple_New(1);
1235     if (!args) {
1236         goto finally;
1237     }
1238     Py_INCREF(self);
1239     PyTuple_SetItem(args, 0, (PyObject*)self);
1240     retval = PyObject_CallObject(pyfn_iterdump, args);
1241
1242 finally:
1243     Py_XDECREF(args);
1244     Py_XDECREF(module);
1245     return retval;
1246 }
1247
1248 static PyObject *
1249 pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args)
1250 {
1251     PyObject* callable;
1252     PyObject* uppercase_name = 0;
1253     PyObject* name;
1254     PyObject* retval;
1255     char* chk;
1256     int rc;
1257
1258     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1259         goto finally;
1260     }
1261
1262     if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyString_Type, &name, &callable)) {
1263         goto finally;
1264     }
1265
1266     uppercase_name = PyObject_CallMethod(name, "upper", "");
1267     if (!uppercase_name) {
1268         goto finally;
1269     }
1270
1271     chk = PyString_AsString(uppercase_name);
1272     while (*chk) {
1273         if ((*chk >= '0' && *chk <= '9')
1274          || (*chk >= 'A' && *chk <= 'Z')
1275          || (*chk == '_'))
1276         {
1277             chk++;
1278         } else {
1279             PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name");
1280             goto finally;
1281         }
1282     }
1283
1284     if (callable != Py_None && !PyCallable_Check(callable)) {
1285         PyErr_SetString(PyExc_TypeError, "parameter must be callable");
1286         goto finally;
1287     }
1288
1289     if (callable != Py_None) {
1290         PyDict_SetItem(self->collations, uppercase_name, callable);
1291     } else {
1292         PyDict_DelItem(self->collations, uppercase_name);
1293     }
1294
1295     rc = sqlite3_create_collation(self->db,
1296                                   PyString_AsString(uppercase_name),
1297                                   SQLITE_UTF8,
1298                                   (callable != Py_None) ? callable : NULL,
1299                                   (callable != Py_None) ? pysqlite_collation_callback : NULL);
1300     if (rc != SQLITE_OK) {
1301         PyDict_DelItem(self->collations, uppercase_name);
1302         _pysqlite_seterror(self->db, NULL);
1303         goto finally;
1304     }
1305
1306 finally:
1307     Py_XDECREF(uppercase_name);
1308
1309     if (PyErr_Occurred()) {
1310         retval = NULL;
1311     } else {
1312         Py_INCREF(Py_None);
1313         retval = Py_None;
1314     }
1315
1316     return retval;
1317 }
1318
1319 /* Called when the connection is used as a context manager. Returns itself as a
1320  * convenience to the caller. */
1321 static PyObject *
1322 pysqlite_connection_enter(pysqlite_Connection* self, PyObject* args)
1323 {
1324     Py_INCREF(self);
1325     return (PyObject*)self;
1326 }
1327
1328 /** Called when the connection is used as a context manager. If there was any
1329  * exception, a rollback takes place; otherwise we commit. */
1330 static PyObject *
1331 pysqlite_connection_exit(pysqlite_Connection* self, PyObject* args)
1332 {
1333     PyObject* exc_type, *exc_value, *exc_tb;
1334     char* method_name;
1335     PyObject* result;
1336
1337     if (!PyArg_ParseTuple(args, "OOO", &exc_type, &exc_value, &exc_tb)) {
1338         return NULL;
1339     }
1340
1341     if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
1342         method_name = "commit";
1343     } else {
1344         method_name = "rollback";
1345     }
1346
1347     result = PyObject_CallMethod((PyObject*)self, method_name, "");
1348     if (!result) {
1349         return NULL;
1350     }
1351     Py_DECREF(result);
1352
1353     Py_INCREF(Py_False);
1354     return Py_False;
1355 }
1356
1357 static char connection_doc[] =
1358 PyDoc_STR("SQLite database connection object.");
1359
1360 static PyGetSetDef connection_getset[] = {
1361     {"isolation_level",  (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
1362     {"total_changes",  (getter)pysqlite_connection_get_total_changes, (setter)0},
1363     {NULL}
1364 };
1365
1366 static PyMethodDef connection_methods[] = {
1367     {"cursor", (PyCFunction)pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS,
1368         PyDoc_STR("Return a cursor for the connection.")},
1369     {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS,
1370         PyDoc_STR("Closes the connection.")},
1371     {"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS,
1372         PyDoc_STR("Commit the current transaction.")},
1373     {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS,
1374         PyDoc_STR("Roll back the current transaction.")},
1375     {"create_function", (PyCFunction)pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS,
1376         PyDoc_STR("Creates a new function. Non-standard.")},
1377     {"create_aggregate", (PyCFunction)pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS,
1378         PyDoc_STR("Creates a new aggregate. Non-standard.")},
1379     {"set_authorizer", (PyCFunction)pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS,
1380         PyDoc_STR("Sets authorizer callback. Non-standard.")},
1381     {"set_progress_handler", (PyCFunction)pysqlite_connection_set_progress_handler, METH_VARARGS|METH_KEYWORDS,
1382         PyDoc_STR("Sets progress handler callback. Non-standard.")},
1383     {"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS,
1384         PyDoc_STR("Executes a SQL statement. Non-standard.")},
1385     {"executemany", (PyCFunction)pysqlite_connection_executemany, METH_VARARGS,
1386         PyDoc_STR("Repeatedly executes a SQL statement. Non-standard.")},
1387     {"executescript", (PyCFunction)pysqlite_connection_executescript, METH_VARARGS,
1388         PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
1389     {"create_collation", (PyCFunction)pysqlite_connection_create_collation, METH_VARARGS,
1390         PyDoc_STR("Creates a collation function. Non-standard.")},
1391     {"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS,
1392         PyDoc_STR("Abort any pending database operation. Non-standard.")},
1393     {"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS,
1394         PyDoc_STR("Returns iterator to the dump of the database in an SQL text format.")},
1395     {"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS,
1396         PyDoc_STR("For context manager. Non-standard.")},
1397     {"__exit__", (PyCFunction)pysqlite_connection_exit, METH_VARARGS,
1398         PyDoc_STR("For context manager. Non-standard.")},
1399     {NULL, NULL}
1400 };
1401
1402 static struct PyMemberDef connection_members[] =
1403 {
1404     {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), RO},
1405     {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), RO},
1406     {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), RO},
1407     {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), RO},
1408     {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), RO},
1409     {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), RO},
1410     {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), RO},
1411     {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), RO},
1412     {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), RO},
1413     {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), RO},
1414     {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)},
1415     {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)},
1416     {NULL}
1417 };
1418
1419 PyTypeObject pysqlite_ConnectionType = {
1420         PyVarObject_HEAD_INIT(NULL, 0)
1421         MODULE_NAME ".Connection",                      /* tp_name */
1422         sizeof(pysqlite_Connection),                    /* tp_basicsize */
1423         0,                                              /* tp_itemsize */
1424         (destructor)pysqlite_connection_dealloc,        /* tp_dealloc */
1425         0,                                              /* tp_print */
1426         0,                                              /* tp_getattr */
1427         0,                                              /* tp_setattr */
1428         0,                                              /* tp_compare */
1429         0,                                              /* tp_repr */
1430         0,                                              /* tp_as_number */
1431         0,                                              /* tp_as_sequence */
1432         0,                                              /* tp_as_mapping */
1433         0,                                              /* tp_hash */
1434         (ternaryfunc)pysqlite_connection_call,          /* tp_call */
1435         0,                                              /* tp_str */
1436         0,                                              /* tp_getattro */
1437         0,                                              /* tp_setattro */
1438         0,                                              /* tp_as_buffer */
1439         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,         /* tp_flags */
1440         connection_doc,                                 /* tp_doc */
1441         0,                                              /* tp_traverse */
1442         0,                                              /* tp_clear */
1443         0,                                              /* tp_richcompare */
1444         0,                                              /* tp_weaklistoffset */
1445         0,                                              /* tp_iter */
1446         0,                                              /* tp_iternext */
1447         connection_methods,                             /* tp_methods */
1448         connection_members,                             /* tp_members */
1449         connection_getset,                              /* tp_getset */
1450         0,                                              /* tp_base */
1451         0,                                              /* tp_dict */
1452         0,                                              /* tp_descr_get */
1453         0,                                              /* tp_descr_set */
1454         0,                                              /* tp_dictoffset */
1455         (initproc)pysqlite_connection_init,             /* tp_init */
1456         0,                                              /* tp_alloc */
1457         0,                                              /* tp_new */
1458         0                                               /* tp_free */
1459 };
1460
1461 extern int pysqlite_connection_setup_types(void)
1462 {
1463     pysqlite_ConnectionType.tp_new = PyType_GenericNew;
1464     return PyType_Ready(&pysqlite_ConnectionType);
1465 }