/Modules/_sqlite/connection.c
C | 1487 lines | 1187 code | 238 blank | 62 comment | 246 complexity | 1e0136e98300cead768e69dc57f0eeb5 MD5 | raw file
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 38static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level); 39 40 41static 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 53int 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#ifdef WITH_THREAD 172 self->thread_ident = PyThread_get_thread_ident(); 173#endif 174 self->check_same_thread = check_same_thread; 175 176 self->function_pinboard = PyDict_New(); 177 if (!self->function_pinboard) { 178 return -1; 179 } 180 181 self->collations = PyDict_New(); 182 if (!self->collations) { 183 return -1; 184 } 185 186 self->Warning = pysqlite_Warning; 187 self->Error = pysqlite_Error; 188 self->InterfaceError = pysqlite_InterfaceError; 189 self->DatabaseError = pysqlite_DatabaseError; 190 self->DataError = pysqlite_DataError; 191 self->OperationalError = pysqlite_OperationalError; 192 self->IntegrityError = pysqlite_IntegrityError; 193 self->InternalError = pysqlite_InternalError; 194 self->ProgrammingError = pysqlite_ProgrammingError; 195 self->NotSupportedError = pysqlite_NotSupportedError; 196 197 return 0; 198} 199 200/* Empty the entire statement cache of this connection */ 201void pysqlite_flush_statement_cache(pysqlite_Connection* self) 202{ 203 pysqlite_Node* node; 204 pysqlite_Statement* statement; 205 206 node = self->statement_cache->first; 207 208 while (node) { 209 statement = (pysqlite_Statement*)(node->data); 210 (void)pysqlite_statement_finalize(statement); 211 node = node->next; 212 } 213 214 Py_DECREF(self->statement_cache); 215 self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "O", self); 216 Py_DECREF(self); 217 self->statement_cache->decref_factory = 0; 218} 219 220/* action in (ACTION_RESET, ACTION_FINALIZE) */ 221void pysqlite_do_all_statements(pysqlite_Connection* self, int action) 222{ 223 int i; 224 PyObject* weakref; 225 PyObject* statement; 226 227 for (i = 0; i < PyList_Size(self->statements); i++) { 228 weakref = PyList_GetItem(self->statements, i); 229 statement = PyWeakref_GetObject(weakref); 230 if (statement != Py_None) { 231 if (action == ACTION_RESET) { 232 (void)pysqlite_statement_reset((pysqlite_Statement*)statement); 233 } else { 234 (void)pysqlite_statement_finalize((pysqlite_Statement*)statement); 235 } 236 } 237 } 238} 239 240void pysqlite_connection_dealloc(pysqlite_Connection* self) 241{ 242 PyObject* ret = NULL; 243 244 Py_XDECREF(self->statement_cache); 245 246 /* Clean up if user has not called .close() explicitly. */ 247 if (self->db) { 248 Py_BEGIN_ALLOW_THREADS 249 sqlite3_close(self->db); 250 Py_END_ALLOW_THREADS 251 } else if (self->apsw_connection) { 252 ret = PyObject_CallMethod(self->apsw_connection, "close", ""); 253 Py_XDECREF(ret); 254 Py_XDECREF(self->apsw_connection); 255 } 256 257 if (self->begin_statement) { 258 PyMem_Free(self->begin_statement); 259 } 260 Py_XDECREF(self->isolation_level); 261 Py_XDECREF(self->function_pinboard); 262 Py_XDECREF(self->row_factory); 263 Py_XDECREF(self->text_factory); 264 Py_XDECREF(self->collations); 265 Py_XDECREF(self->statements); 266 267 self->ob_type->tp_free((PyObject*)self); 268} 269 270PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 271{ 272 static char *kwlist[] = {"factory", NULL, NULL}; 273 PyObject* factory = NULL; 274 PyObject* cursor; 275 276 277 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, 278 &factory)) { 279 return NULL; 280 } 281 282 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 283 return NULL; 284 } 285 286 if (factory == NULL) { 287 factory = (PyObject*)&pysqlite_CursorType; 288 } 289 290 cursor = PyObject_CallFunction(factory, "O", self); 291 292 if (cursor && self->row_factory != Py_None) { 293 Py_XDECREF(((pysqlite_Cursor*)cursor)->row_factory); 294 Py_INCREF(self->row_factory); 295 ((pysqlite_Cursor*)cursor)->row_factory = self->row_factory; 296 } 297 298 return cursor; 299} 300 301PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args) 302{ 303 PyObject* ret; 304 int rc; 305 306 if (!pysqlite_check_thread(self)) { 307 return NULL; 308 } 309 310 pysqlite_do_all_statements(self, ACTION_FINALIZE); 311 312 if (self->db) { 313 if (self->apsw_connection) { 314 ret = PyObject_CallMethod(self->apsw_connection, "close", ""); 315 Py_XDECREF(ret); 316 Py_XDECREF(self->apsw_connection); 317 self->apsw_connection = NULL; 318 self->db = NULL; 319 } else { 320 Py_BEGIN_ALLOW_THREADS 321 rc = sqlite3_close(self->db); 322 Py_END_ALLOW_THREADS 323 324 if (rc != SQLITE_OK) { 325 _pysqlite_seterror(self->db, NULL); 326 return NULL; 327 } else { 328 self->db = NULL; 329 } 330 } 331 } 332 333 Py_INCREF(Py_None); 334 return Py_None; 335} 336 337/* 338 * Checks if a connection object is usable (i. e. not closed). 339 * 340 * 0 => error; 1 => ok 341 */ 342int pysqlite_check_connection(pysqlite_Connection* con) 343{ 344 if (!con->db) { 345 PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database."); 346 return 0; 347 } else { 348 return 1; 349 } 350} 351 352PyObject* _pysqlite_connection_begin(pysqlite_Connection* self) 353{ 354 int rc; 355 const char* tail; 356 sqlite3_stmt* statement; 357 358 Py_BEGIN_ALLOW_THREADS 359 rc = sqlite3_prepare(self->db, self->begin_statement, -1, &statement, &tail); 360 Py_END_ALLOW_THREADS 361 362 if (rc != SQLITE_OK) { 363 _pysqlite_seterror(self->db, statement); 364 goto error; 365 } 366 367 rc = pysqlite_step(statement, self); 368 if (rc == SQLITE_DONE) { 369 self->inTransaction = 1; 370 } else { 371 _pysqlite_seterror(self->db, statement); 372 } 373 374 Py_BEGIN_ALLOW_THREADS 375 rc = sqlite3_finalize(statement); 376 Py_END_ALLOW_THREADS 377 378 if (rc != SQLITE_OK && !PyErr_Occurred()) { 379 _pysqlite_seterror(self->db, NULL); 380 } 381 382error: 383 if (PyErr_Occurred()) { 384 return NULL; 385 } else { 386 Py_INCREF(Py_None); 387 return Py_None; 388 } 389} 390 391PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args) 392{ 393 int rc; 394 const char* tail; 395 sqlite3_stmt* statement; 396 397 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 398 return NULL; 399 } 400 401 if (self->inTransaction) { 402 Py_BEGIN_ALLOW_THREADS 403 rc = sqlite3_prepare(self->db, "COMMIT", -1, &statement, &tail); 404 Py_END_ALLOW_THREADS 405 if (rc != SQLITE_OK) { 406 _pysqlite_seterror(self->db, NULL); 407 goto error; 408 } 409 410 rc = pysqlite_step(statement, self); 411 if (rc == SQLITE_DONE) { 412 self->inTransaction = 0; 413 } else { 414 _pysqlite_seterror(self->db, statement); 415 } 416 417 Py_BEGIN_ALLOW_THREADS 418 rc = sqlite3_finalize(statement); 419 Py_END_ALLOW_THREADS 420 if (rc != SQLITE_OK && !PyErr_Occurred()) { 421 _pysqlite_seterror(self->db, NULL); 422 } 423 424 } 425 426error: 427 if (PyErr_Occurred()) { 428 return NULL; 429 } else { 430 Py_INCREF(Py_None); 431 return Py_None; 432 } 433} 434 435PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args) 436{ 437 int rc; 438 const char* tail; 439 sqlite3_stmt* statement; 440 441 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 442 return NULL; 443 } 444 445 if (self->inTransaction) { 446 pysqlite_do_all_statements(self, ACTION_RESET); 447 448 Py_BEGIN_ALLOW_THREADS 449 rc = sqlite3_prepare(self->db, "ROLLBACK", -1, &statement, &tail); 450 Py_END_ALLOW_THREADS 451 if (rc != SQLITE_OK) { 452 _pysqlite_seterror(self->db, NULL); 453 goto error; 454 } 455 456 rc = pysqlite_step(statement, self); 457 if (rc == SQLITE_DONE) { 458 self->inTransaction = 0; 459 } else { 460 _pysqlite_seterror(self->db, statement); 461 } 462 463 Py_BEGIN_ALLOW_THREADS 464 rc = sqlite3_finalize(statement); 465 Py_END_ALLOW_THREADS 466 if (rc != SQLITE_OK && !PyErr_Occurred()) { 467 _pysqlite_seterror(self->db, NULL); 468 } 469 470 } 471 472error: 473 if (PyErr_Occurred()) { 474 return NULL; 475 } else { 476 Py_INCREF(Py_None); 477 return Py_None; 478 } 479} 480 481void _pysqlite_set_result(sqlite3_context* context, PyObject* py_val) 482{ 483 long longval; 484 const char* buffer; 485 Py_ssize_t buflen; 486 PyObject* stringval; 487 488 if ((!py_val) || PyErr_Occurred()) { 489 sqlite3_result_null(context); 490 } else if (py_val == Py_None) { 491 sqlite3_result_null(context); 492 } else if (PyInt_Check(py_val)) { 493 longval = PyInt_AsLong(py_val); 494 sqlite3_result_int64(context, (PY_LONG_LONG)longval); 495 } else if (PyFloat_Check(py_val)) { 496 sqlite3_result_double(context, PyFloat_AsDouble(py_val)); 497 } else if (PyBuffer_Check(py_val)) { 498 if (PyObject_AsCharBuffer(py_val, &buffer, &buflen) != 0) { 499 PyErr_SetString(PyExc_ValueError, "could not convert BLOB to buffer"); 500 } else { 501 sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT); 502 } 503 } else if (PyString_Check(py_val)) { 504 sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT); 505 } else if (PyUnicode_Check(py_val)) { 506 stringval = PyUnicode_AsUTF8String(py_val); 507 if (stringval) { 508 sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT); 509 Py_DECREF(stringval); 510 } 511 } else { 512 /* TODO: raise error */ 513 } 514} 515 516PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv) 517{ 518 PyObject* args; 519 int i; 520 sqlite3_value* cur_value; 521 PyObject* cur_py_value; 522 const char* val_str; 523 PY_LONG_LONG val_int; 524 Py_ssize_t buflen; 525 void* raw_buffer; 526 527 args = PyTuple_New(argc); 528 if (!args) { 529 return NULL; 530 } 531 532 for (i = 0; i < argc; i++) { 533 cur_value = argv[i]; 534 switch (sqlite3_value_type(argv[i])) { 535 case SQLITE_INTEGER: 536 val_int = sqlite3_value_int64(cur_value); 537 cur_py_value = PyInt_FromLong((long)val_int); 538 break; 539 case SQLITE_FLOAT: 540 cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value)); 541 break; 542 case SQLITE_TEXT: 543 val_str = (const char*)sqlite3_value_text(cur_value); 544 cur_py_value = PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL); 545 /* TODO: have a way to show errors here */ 546 if (!cur_py_value) { 547 PyErr_Clear(); 548 Py_INCREF(Py_None); 549 cur_py_value = Py_None; 550 } 551 break; 552 case SQLITE_BLOB: 553 buflen = sqlite3_value_bytes(cur_value); 554 cur_py_value = PyBuffer_New(buflen); 555 if (!cur_py_value) { 556 break; 557 } 558 if (PyObject_AsWriteBuffer(cur_py_value, &raw_buffer, &buflen)) { 559 Py_DECREF(cur_py_value); 560 cur_py_value = NULL; 561 break; 562 } 563 memcpy(raw_buffer, sqlite3_value_blob(cur_value), buflen); 564 break; 565 case SQLITE_NULL: 566 default: 567 Py_INCREF(Py_None); 568 cur_py_value = Py_None; 569 } 570 571 if (!cur_py_value) { 572 Py_DECREF(args); 573 return NULL; 574 } 575 576 PyTuple_SetItem(args, i, cur_py_value); 577 578 } 579 580 return args; 581} 582 583void _pysqlite_func_callback(sqlite3_context* context, int argc, sqlite3_value** argv) 584{ 585 PyObject* args; 586 PyObject* py_func; 587 PyObject* py_retval = NULL; 588 589#ifdef WITH_THREAD 590 PyGILState_STATE threadstate; 591 592 threadstate = PyGILState_Ensure(); 593#endif 594 595 py_func = (PyObject*)sqlite3_user_data(context); 596 597 args = _pysqlite_build_py_params(context, argc, argv); 598 if (args) { 599 py_retval = PyObject_CallObject(py_func, args); 600 Py_DECREF(args); 601 } 602 603 if (py_retval) { 604 _pysqlite_set_result(context, py_retval); 605 Py_DECREF(py_retval); 606 } else { 607 if (_enable_callback_tracebacks) { 608 PyErr_Print(); 609 } else { 610 PyErr_Clear(); 611 } 612 _sqlite3_result_error(context, "user-defined function raised exception", -1); 613 } 614 615#ifdef WITH_THREAD 616 PyGILState_Release(threadstate); 617#endif 618} 619 620static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params) 621{ 622 PyObject* args; 623 PyObject* function_result = NULL; 624 PyObject* aggregate_class; 625 PyObject** aggregate_instance; 626 PyObject* stepmethod = NULL; 627 628#ifdef WITH_THREAD 629 PyGILState_STATE threadstate; 630 631 threadstate = PyGILState_Ensure(); 632#endif 633 634 aggregate_class = (PyObject*)sqlite3_user_data(context); 635 636 aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*)); 637 638 if (*aggregate_instance == 0) { 639 *aggregate_instance = PyObject_CallFunction(aggregate_class, ""); 640 641 if (PyErr_Occurred()) { 642 *aggregate_instance = 0; 643 if (_enable_callback_tracebacks) { 644 PyErr_Print(); 645 } else { 646 PyErr_Clear(); 647 } 648 _sqlite3_result_error(context, "user-defined aggregate's '__init__' method raised error", -1); 649 goto error; 650 } 651 } 652 653 stepmethod = PyObject_GetAttrString(*aggregate_instance, "step"); 654 if (!stepmethod) { 655 goto error; 656 } 657 658 args = _pysqlite_build_py_params(context, argc, params); 659 if (!args) { 660 goto error; 661 } 662 663 function_result = PyObject_CallObject(stepmethod, args); 664 Py_DECREF(args); 665 666 if (!function_result) { 667 if (_enable_callback_tracebacks) { 668 PyErr_Print(); 669 } else { 670 PyErr_Clear(); 671 } 672 _sqlite3_result_error(context, "user-defined aggregate's 'step' method raised error", -1); 673 } 674 675error: 676 Py_XDECREF(stepmethod); 677 Py_XDECREF(function_result); 678 679#ifdef WITH_THREAD 680 PyGILState_Release(threadstate); 681#endif 682} 683 684void _pysqlite_final_callback(sqlite3_context* context) 685{ 686 PyObject* function_result = NULL; 687 PyObject** aggregate_instance; 688 PyObject* aggregate_class; 689 690#ifdef WITH_THREAD 691 PyGILState_STATE threadstate; 692 693 threadstate = PyGILState_Ensure(); 694#endif 695 696 aggregate_class = (PyObject*)sqlite3_user_data(context); 697 698 aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*)); 699 if (!*aggregate_instance) { 700 /* this branch is executed if there was an exception in the aggregate's 701 * __init__ */ 702 703 goto error; 704 } 705 706 function_result = PyObject_CallMethod(*aggregate_instance, "finalize", ""); 707 if (!function_result) { 708 if (_enable_callback_tracebacks) { 709 PyErr_Print(); 710 } else { 711 PyErr_Clear(); 712 } 713 _sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1); 714 } else { 715 _pysqlite_set_result(context, function_result); 716 } 717 718error: 719 Py_XDECREF(*aggregate_instance); 720 Py_XDECREF(function_result); 721 722#ifdef WITH_THREAD 723 PyGILState_Release(threadstate); 724#endif 725} 726 727void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self) 728{ 729 PyObject* new_list; 730 PyObject* weakref; 731 int i; 732 733 /* we only need to do this once in a while */ 734 if (self->created_statements++ < 200) { 735 return; 736 } 737 738 self->created_statements = 0; 739 740 new_list = PyList_New(0); 741 if (!new_list) { 742 return; 743 } 744 745 for (i = 0; i < PyList_Size(self->statements); i++) { 746 weakref = PyList_GetItem(self->statements, i); 747 if (PyWeakref_GetObject(weakref) != Py_None) { 748 if (PyList_Append(new_list, weakref) != 0) { 749 Py_DECREF(new_list); 750 return; 751 } 752 } 753 } 754 755 Py_DECREF(self->statements); 756 self->statements = new_list; 757} 758 759PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 760{ 761 static char *kwlist[] = {"name", "narg", "func", NULL, NULL}; 762 763 PyObject* func; 764 char* name; 765 int narg; 766 int rc; 767 768 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO", kwlist, 769 &name, &narg, &func)) 770 { 771 return NULL; 772 } 773 774 rc = sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _pysqlite_func_callback, NULL, NULL); 775 776 if (rc != SQLITE_OK) { 777 /* Workaround for SQLite bug: no error code or string is available here */ 778 PyErr_SetString(pysqlite_OperationalError, "Error creating function"); 779 return NULL; 780 } else { 781 PyDict_SetItem(self->function_pinboard, func, Py_None); 782 783 Py_INCREF(Py_None); 784 return Py_None; 785 } 786} 787 788PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 789{ 790 PyObject* aggregate_class; 791 792 int n_arg; 793 char* name; 794 static char *kwlist[] = { "name", "n_arg", "aggregate_class", NULL }; 795 int rc; 796 797 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO:create_aggregate", 798 kwlist, &name, &n_arg, &aggregate_class)) { 799 return NULL; 800 } 801 802 rc = sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_pysqlite_step_callback, &_pysqlite_final_callback); 803 if (rc != SQLITE_OK) { 804 /* Workaround for SQLite bug: no error code or string is available here */ 805 PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate"); 806 return NULL; 807 } else { 808 PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None); 809 810 Py_INCREF(Py_None); 811 return Py_None; 812 } 813} 814 815static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source) 816{ 817 PyObject *ret; 818 int rc; 819#ifdef WITH_THREAD 820 PyGILState_STATE gilstate; 821 822 gilstate = PyGILState_Ensure(); 823#endif 824 ret = PyObject_CallFunction((PyObject*)user_arg, "issss", action, arg1, arg2, dbname, access_attempt_source); 825 826 if (!ret) { 827 if (_enable_callback_tracebacks) { 828 PyErr_Print(); 829 } else { 830 PyErr_Clear(); 831 } 832 833 rc = SQLITE_DENY; 834 } else { 835 if (PyInt_Check(ret)) { 836 rc = (int)PyInt_AsLong(ret); 837 } else { 838 rc = SQLITE_DENY; 839 } 840 Py_DECREF(ret); 841 } 842 843#ifdef WITH_THREAD 844 PyGILState_Release(gilstate); 845#endif 846 return rc; 847} 848 849static int _progress_handler(void* user_arg) 850{ 851 int rc; 852 PyObject *ret; 853#ifdef WITH_THREAD 854 PyGILState_STATE gilstate; 855 856 gilstate = PyGILState_Ensure(); 857#endif 858 ret = PyObject_CallFunction((PyObject*)user_arg, ""); 859 860 if (!ret) { 861 if (_enable_callback_tracebacks) { 862 PyErr_Print(); 863 } else { 864 PyErr_Clear(); 865 } 866 867 /* abort query if error occurred */ 868 rc = 1; 869 } else { 870 rc = (int)PyObject_IsTrue(ret); 871 Py_DECREF(ret); 872 } 873 874#ifdef WITH_THREAD 875 PyGILState_Release(gilstate); 876#endif 877 return rc; 878} 879 880PyObject* pysqlite_connection_set_authorizer(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 881{ 882 PyObject* authorizer_cb; 883 884 static char *kwlist[] = { "authorizer_callback", NULL }; 885 int rc; 886 887 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_authorizer", 888 kwlist, &authorizer_cb)) { 889 return NULL; 890 } 891 892 rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb); 893 894 if (rc != SQLITE_OK) { 895 PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback"); 896 return NULL; 897 } else { 898 PyDict_SetItem(self->function_pinboard, authorizer_cb, Py_None); 899 900 Py_INCREF(Py_None); 901 return Py_None; 902 } 903} 904 905PyObject* pysqlite_connection_set_progress_handler(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 906{ 907 PyObject* progress_handler; 908 int n; 909 910 static char *kwlist[] = { "progress_handler", "n", NULL }; 911 912 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi:set_progress_handler", 913 kwlist, &progress_handler, &n)) { 914 return NULL; 915 } 916 917 if (progress_handler == Py_None) { 918 /* None clears the progress handler previously set */ 919 sqlite3_progress_handler(self->db, 0, 0, (void*)0); 920 } else { 921 sqlite3_progress_handler(self->db, n, _progress_handler, progress_handler); 922 PyDict_SetItem(self->function_pinboard, progress_handler, Py_None); 923 } 924 925 Py_INCREF(Py_None); 926 return Py_None; 927} 928 929int pysqlite_check_thread(pysqlite_Connection* self) 930{ 931#ifdef WITH_THREAD 932 if (self->check_same_thread) { 933 if (PyThread_get_thread_ident() != self->thread_ident) { 934 PyErr_Format(pysqlite_ProgrammingError, 935 "SQLite objects created in a thread can only be used in that same thread." 936 "The object was created in thread id %ld and this is thread id %ld", 937 self->thread_ident, PyThread_get_thread_ident()); 938 return 0; 939 } 940 941 } 942#endif 943 return 1; 944} 945 946static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused) 947{ 948 Py_INCREF(self->isolation_level); 949 return self->isolation_level; 950} 951 952static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused) 953{ 954 if (!pysqlite_check_connection(self)) { 955 return NULL; 956 } else { 957 return Py_BuildValue("i", sqlite3_total_changes(self->db)); 958 } 959} 960 961static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level) 962{ 963 PyObject* res; 964 PyObject* begin_statement; 965 char* begin_statement_str; 966 967 Py_XDECREF(self->isolation_level); 968 969 if (self->begin_statement) { 970 PyMem_Free(self->begin_statement); 971 self->begin_statement = NULL; 972 } 973 974 if (isolation_level == Py_None) { 975 Py_INCREF(Py_None); 976 self->isolation_level = Py_None; 977 978 res = pysqlite_connection_commit(self, NULL); 979 if (!res) { 980 return -1; 981 } 982 Py_DECREF(res); 983 984 self->inTransaction = 0; 985 } else { 986 Py_INCREF(isolation_level); 987 self->isolation_level = isolation_level; 988 989 begin_statement = PyString_FromString("BEGIN "); 990 if (!begin_statement) { 991 return -1; 992 } 993 PyString_Concat(&begin_statement, isolation_level); 994 if (!begin_statement) { 995 return -1; 996 } 997 998 begin_statement_str = PyString_AsString(begin_statement); 999 if (!begin_statement_str) { 1000 Py_DECREF(begin_statement); 1001 return -1; 1002 } 1003 self->begin_statement = PyMem_Malloc(strlen(begin_statement_str) + 2); 1004 if (!self->begin_statement) { 1005 Py_DECREF(begin_statement); 1006 return -1; 1007 } 1008 1009 strcpy(self->begin_statement, begin_statement_str); 1010 Py_DECREF(begin_statement); 1011 } 1012 1013 return 0; 1014} 1015 1016PyObject* pysqlite_connection_call(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 1017{ 1018 PyObject* sql; 1019 pysqlite_Statement* statement; 1020 PyObject* weakref; 1021 int rc; 1022 1023 if (!PyArg_ParseTuple(args, "O", &sql)) { 1024 return NULL; 1025 } 1026 1027 _pysqlite_drop_unused_statement_references(self); 1028 1029 statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType); 1030 if (!statement) { 1031 return NULL; 1032 } 1033 1034 rc = pysqlite_statement_create(statement, self, sql); 1035 1036 if (rc != SQLITE_OK) { 1037 if (rc == PYSQLITE_TOO_MUCH_SQL) { 1038 PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time."); 1039 } else if (rc == PYSQLITE_SQL_WRONG_TYPE) { 1040 PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string or unicode."); 1041 } else { 1042 (void)pysqlite_statement_reset(statement); 1043 _pysqlite_seterror(self->db, NULL); 1044 } 1045 1046 Py_CLEAR(statement); 1047 } else { 1048 weakref = PyWeakref_NewRef((PyObject*)statement, NULL); 1049 if (!weakref) { 1050 Py_CLEAR(statement); 1051 goto error; 1052 } 1053 1054 if (PyList_Append(self->statements, weakref) != 0) { 1055 Py_CLEAR(weakref); 1056 goto error; 1057 } 1058 1059 Py_DECREF(weakref); 1060 } 1061 1062error: 1063 return (PyObject*)statement; 1064} 1065 1066PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 1067{ 1068 PyObject* cursor = 0; 1069 PyObject* result = 0; 1070 PyObject* method = 0; 1071 1072 cursor = PyObject_CallMethod((PyObject*)self, "cursor", ""); 1073 if (!cursor) { 1074 goto error; 1075 } 1076 1077 method = PyObject_GetAttrString(cursor, "execute"); 1078 if (!method) { 1079 Py_CLEAR(cursor); 1080 goto error; 1081 } 1082 1083 result = PyObject_CallObject(method, args); 1084 if (!result) { 1085 Py_CLEAR(cursor); 1086 } 1087 1088error: 1089 Py_XDECREF(result); 1090 Py_XDECREF(method); 1091 1092 return cursor; 1093} 1094 1095PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 1096{ 1097 PyObject* cursor = 0; 1098 PyObject* result = 0; 1099 PyObject* method = 0; 1100 1101 cursor = PyObject_CallMethod((PyObject*)self, "cursor", ""); 1102 if (!cursor) { 1103 goto error; 1104 } 1105 1106 method = PyObject_GetAttrString(cursor, "executemany"); 1107 if (!method) { 1108 Py_CLEAR(cursor); 1109 goto error; 1110 } 1111 1112 result = PyObject_CallObject(method, args); 1113 if (!result) { 1114 Py_CLEAR(cursor); 1115 } 1116 1117error: 1118 Py_XDECREF(result); 1119 Py_XDECREF(method); 1120 1121 return cursor; 1122} 1123 1124PyObject* pysqlite_connection_executescript(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) 1125{ 1126 PyObject* cursor = 0; 1127 PyObject* result = 0; 1128 PyObject* method = 0; 1129 1130 cursor = PyObject_CallMethod((PyObject*)self, "cursor", ""); 1131 if (!cursor) { 1132 goto error; 1133 } 1134 1135 method = PyObject_GetAttrString(cursor, "executescript"); 1136 if (!method) { 1137 Py_CLEAR(cursor); 1138 goto error; 1139 } 1140 1141 result = PyObject_CallObject(method, args); 1142 if (!result) { 1143 Py_CLEAR(cursor); 1144 } 1145 1146error: 1147 Py_XDECREF(result); 1148 Py_XDECREF(method); 1149 1150 return cursor; 1151} 1152 1153/* ------------------------- COLLATION CODE ------------------------ */ 1154 1155static int 1156pysqlite_collation_callback( 1157 void* context, 1158 int text1_length, const void* text1_data, 1159 int text2_length, const void* text2_data) 1160{ 1161 PyObject* callback = (PyObject*)context; 1162 PyObject* string1 = 0; 1163 PyObject* string2 = 0; 1164#ifdef WITH_THREAD 1165 PyGILState_STATE gilstate; 1166#endif 1167 PyObject* retval = NULL; 1168 int result = 0; 1169#ifdef WITH_THREAD 1170 gilstate = PyGILState_Ensure(); 1171#endif 1172 1173 if (PyErr_Occurred()) { 1174 goto finally; 1175 } 1176 1177 string1 = PyString_FromStringAndSize((const char*)text1_data, text1_length); 1178 string2 = PyString_FromStringAndSize((const char*)text2_data, text2_length); 1179 1180 if (!string1 || !string2) { 1181 goto finally; /* failed to allocate strings */ 1182 } 1183 1184 retval = PyObject_CallFunctionObjArgs(callback, string1, string2, NULL); 1185 1186 if (!retval) { 1187 /* execution failed */ 1188 goto finally; 1189 } 1190 1191 result = PyInt_AsLong(retval); 1192 if (PyErr_Occurred()) { 1193 result = 0; 1194 } 1195 1196finally: 1197 Py_XDECREF(string1); 1198 Py_XDECREF(string2); 1199 Py_XDECREF(retval); 1200#ifdef WITH_THREAD 1201 PyGILState_Release(gilstate); 1202#endif 1203 return result; 1204} 1205 1206static PyObject * 1207pysqlite_connection_interrupt(pysqlite_Connection* self, PyObject* args) 1208{ 1209 PyObject* retval = NULL; 1210 1211 if (!pysqlite_check_connection(self)) { 1212 goto finally; 1213 } 1214 1215 sqlite3_interrupt(self->db); 1216 1217 Py_INCREF(Py_None); 1218 retval = Py_None; 1219 1220finally: 1221 return retval; 1222} 1223 1224/* Function author: Paul Kippes <kippesp@gmail.com> 1225 * Class method of Connection to call the Python function _iterdump 1226 * of the sqlite3 module. 1227 */ 1228static PyObject * 1229pysqlite_connection_iterdump(pysqlite_Connection* self, PyObject* args) 1230{ 1231 PyObject* retval = NULL; 1232 PyObject* module = NULL; 1233 PyObject* module_dict; 1234 PyObject* pyfn_iterdump; 1235 1236 if (!pysqlite_check_connection(self)) { 1237 goto finally; 1238 } 1239 1240 module = PyImport_ImportModule(MODULE_NAME ".dump"); 1241 if (!module) { 1242 goto finally; 1243 } 1244 1245 module_dict = PyModule_GetDict(module); 1246 if (!module_dict) { 1247 goto finally; 1248 } 1249 1250 pyfn_iterdump = PyDict_GetItemString(module_dict, "_iterdump"); 1251 if (!pyfn_iterdump) { 1252 PyErr_SetString(pysqlite_OperationalError, "Failed to obtain _iterdump() reference"); 1253 goto finally; 1254 } 1255 1256 args = PyTuple_New(1); 1257 if (!args) { 1258 goto finally; 1259 } 1260 Py_INCREF(self); 1261 PyTuple_SetItem(args, 0, (PyObject*)self); 1262 retval = PyObject_CallObject(pyfn_iterdump, args); 1263 1264finally: 1265 Py_XDECREF(args); 1266 Py_XDECREF(module); 1267 return retval; 1268} 1269 1270static PyObject * 1271pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args) 1272{ 1273 PyObject* callable; 1274 PyObject* uppercase_name = 0; 1275 PyObject* name; 1276 PyObject* retval; 1277 char* chk; 1278 int rc; 1279 1280 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { 1281 goto finally; 1282 } 1283 1284 if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyString_Type, &name, &callable)) { 1285 goto finally; 1286 } 1287 1288 uppercase_name = PyObject_CallMethod(name, "upper", ""); 1289 if (!uppercase_name) { 1290 goto finally; 1291 } 1292 1293 chk = PyString_AsString(uppercase_name); 1294 while (*chk) { 1295 if ((*chk >= '0' && *chk <= '9') 1296 || (*chk >= 'A' && *chk <= 'Z') 1297 || (*chk == '_')) 1298 { 1299 chk++; 1300 } else { 1301 PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name"); 1302 goto finally; 1303 } 1304 } 1305 1306 if (callable != Py_None && !PyCallable_Check(callable)) { 1307 PyErr_SetString(PyExc_TypeError, "parameter must be callable"); 1308 goto finally; 1309 } 1310 1311 if (callable != Py_None) { 1312 PyDict_SetItem(self->collations, uppercase_name, callable); 1313 } else { 1314 PyDict_DelItem(self->collations, uppercase_name); 1315 } 1316 1317 rc = sqlite3_create_collation(self->db, 1318 PyString_AsString(uppercase_name), 1319 SQLITE_UTF8, 1320 (callable != Py_None) ? callable : NULL, 1321 (callable != Py_None) ? pysqlite_collation_callback : NULL); 1322 if (rc != SQLITE_OK) { 1323 PyDict_DelItem(self->collations, uppercase_name); 1324 _pysqlite_seterror(self->db, NULL); 1325 goto finally; 1326 } 1327 1328finally: 1329 Py_XDECREF(uppercase_name); 1330 1331 if (PyErr_Occurred()) { 1332 retval = NULL; 1333 } else { 1334 Py_INCREF(Py_None); 1335 retval = Py_None; 1336 } 1337 1338 return retval; 1339} 1340 1341/* Called when the connection is used as a context manager. Returns itself as a 1342 * convenience to the caller. */ 1343static PyObject * 1344pysqlite_connection_enter(pysqlite_Connection* self, PyObject* args) 1345{ 1346 Py_INCREF(self); 1347 return (PyObject*)self; 1348} 1349 1350/** Called when the connection is used as a context manager. If there was any 1351 * exception, a rollback takes place; otherwise we commit. */ 1352static PyObject * 1353pysqlite_connection_exit(pysqlite_Connection* self, PyObject* args) 1354{ 1355 PyObject* exc_type, *exc_value, *exc_tb; 1356 char* method_name; 1357 PyObject* result; 1358 1359 if (!PyArg_ParseTuple(args, "OOO", &exc_type, &exc_value, &exc_tb)) { 1360 return NULL; 1361 } 1362 1363 if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) { 1364 method_name = "commit"; 1365 } else { 1366 method_name = "rollback"; 1367 } 1368 1369 result = PyObject_CallMethod((PyObject*)self, method_name, ""); 1370 if (!result) { 1371 return NULL; 1372 } 1373 Py_DECREF(result); 1374 1375 Py_INCREF(Py_False); 1376 return Py_False; 1377} 1378 1379static char connection_doc[] = 1380PyDoc_STR("SQLite database connection object."); 1381 1382static PyGetSetDef connection_getset[] = { 1383 {"isolation_level", (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level}, 1384 {"total_changes", (getter)pysqlite_connection_get_total_changes, (setter)0}, 1385 {NULL} 1386}; 1387 1388static PyMethodDef connection_methods[] = { 1389 {"cursor", (PyCFunction)pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS, 1390 PyDoc_STR("Return a cursor for the connection.")}, 1391 {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS, 1392 PyDoc_STR("Closes the connection.")}, 1393 {"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS, 1394 PyDoc_STR("Commit the current transaction.")}, 1395 {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS, 1396 PyDoc_STR("Roll back the current transaction.")}, 1397 {"create_function", (PyCFunction)pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS, 1398 PyDoc_STR("Creates a new function. Non-standard.")}, 1399 {"create_aggregate", (PyCFunction)pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS, 1400 PyDoc_STR("Creates a new aggregate. Non-standard.")}, 1401 {"set_authorizer", (PyCFunction)pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS, 1402 PyDoc_STR("Sets authorizer callback. Non-standard.")}, 1403 {"set_progress_handler", (PyCFunction)pysqlite_connection_set_progress_handler, METH_VARARGS|METH_KEYWORDS, 1404 PyDoc_STR("Sets progress handler callback. Non-standard.")}, 1405 {"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS, 1406 PyDoc_STR("Executes a SQL statement. Non-standard.")}, 1407 {"executemany", (PyCFunction)pysqlite_connection_executemany, METH_VARARGS, 1408 PyDoc_STR("Repeatedly executes a SQL statement. Non-standard.")}, 1409 {"executescript", (PyCFunction)pysqlite_connection_executescript, METH_VARARGS, 1410 PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")}, 1411 {"create_collation", (PyCFunction)pysqlite_connection_create_collation, METH_VARARGS, 1412 PyDoc_STR("Creates a collation function. Non-standard.")}, 1413 {"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS, 1414 PyDoc_STR("Abort any pending database operation. Non-standard.")}, 1415 {"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS, 1416 PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")}, 1417 {"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS, 1418 PyDoc_STR("For context manager. Non-standard.")}, 1419 {"__exit__", (PyCFunction)pysqlite_connection_exit, METH_VARARGS, 1420 PyDoc_STR("For context manager. Non-standard.")}, 1421 {NULL, NULL} 1422}; 1423 1424static struct PyMemberDef connection_members[] = 1425{ 1426 {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), RO}, 1427 {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), RO}, 1428 {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), RO}, 1429 {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), RO}, 1430 {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), RO}, 1431 {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), RO}, 1432 {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), RO}, 1433 {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), RO}, 1434 {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), RO}, 1435 {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), RO}, 1436 {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)}, 1437 {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)}, 1438 {NULL} 1439}; 1440 1441PyTypeObject pysqlite_ConnectionType = { 1442 PyVarObject_HEAD_INIT(NULL, 0) 1443 MODULE_NAME ".Connection", /* tp_name */ 1444 sizeof(pysqlite_Connection), /* tp_basicsize */ 1445 0, /* tp_itemsize */ 1446 (destructor)pysqlite_connection_dealloc, /* tp_dealloc */ 1447 0, /* tp_print */ 1448 0, /* tp_getattr */ 1449 0, /* tp_setattr */ 1450 0, /* tp_compare */ 1451 0, /* tp_repr */ 1452 0, /* tp_as_number */ 1453 0, /* tp_as_sequence */ 1454 0, /* tp_as_mapping */ 1455 0, /* tp_hash */ 1456 (ternaryfunc)pysqlite_connection_call, /* tp_call */ 1457 0, /* tp_str */ 1458 0, /* tp_getattro */ 1459 0, /* tp_setattro */ 1460 0, /* tp_as_buffer */ 1461 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 1462 connection_doc, /* tp_doc */ 1463 0, /* tp_traverse */ 1464 0, /* tp_clear */ 1465 0, /* tp_richcompare */ 1466 0, /* tp_weaklistoffset */ 1467 0, /* tp_iter */ 1468 0, /* tp_iternext */ 1469 connection_methods, /* tp_methods */ 1470 connection_members, /* tp_members */ 1471 connection_getset, /* tp_getset */ 1472 0, /* tp_base */ 1473 0, /* tp_dict */ 1474 0, /* tp_descr_get */ 1475 0, /* tp_descr_set */ 1476 0, /* tp_dictoffset */ 1477 (initproc)pysqlite_connection_init, /* tp_init */ 1478 0, /* tp_alloc */ 1479 0, /* tp_new */ 1480 0 /* tp_free */ 1481}; 1482 1483extern int pysqlite_connection_setup_types(void) 1484{ 1485 pysqlite_ConnectionType.tp_new = PyType_GenericNew; 1486 return PyType_Ready(&pysqlite_ConnectionType); 1487}