PageRenderTime 2336ms CodeModel.GetById 806ms app.highlight 650ms RepoModel.GetById 673ms app.codeStats 0ms

/Modules/_sqlite/connection.c

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