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