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