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