LCOV - code coverage report
Current view: | top level - Modules/_sqlite - connection.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 6 | 921 | 0.7 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 1 | 63 | 1.6 %
|  |  | Branches: | 1 | 561 | 0.2 %

               Branch data     Line data    Source code
           1                 :            : /* connection.c - the connection type
           2                 :            :  *
           3                 :            :  * Copyright (C) 2004-2010 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 "module.h"
          25                 :            : #include "structmember.h"         // PyMemberDef
          26                 :            : #include "connection.h"
          27                 :            : #include "statement.h"
          28                 :            : #include "cursor.h"
          29                 :            : #include "blob.h"
          30                 :            : #include "prepare_protocol.h"
          31                 :            : #include "util.h"
          32                 :            :
          33                 :            : #if SQLITE_VERSION_NUMBER >= 3014000
          34                 :            : #define HAVE_TRACE_V2
          35                 :            : #endif
          36                 :            :
          37                 :            : #if SQLITE_VERSION_NUMBER >= 3025000
          38                 :            : #define HAVE_WINDOW_FUNCTIONS
          39                 :            : #endif
          40                 :            :
          41                 :            : static const char *
          42                 :          0 : get_isolation_level(const char *level)
          43                 :            : {
          44                 :            :     assert(level != NULL);
          45                 :            :     static const char *const allowed_levels[] = {
          46                 :            :         "",
          47                 :            :         "DEFERRED",
          48                 :            :         "IMMEDIATE",
          49                 :            :         "EXCLUSIVE",
          50                 :            :         NULL
          51                 :            :     };
          52         [ #  # ]:          0 :     for (int i = 0; allowed_levels[i] != NULL; i++) {
          53                 :          0 :         const char *candidate = allowed_levels[i];
          54         [ #  # ]:          0 :         if (sqlite3_stricmp(level, candidate) == 0) {
          55                 :          0 :             return candidate;
          56                 :            :         }
          57                 :            :     }
          58                 :          0 :     PyErr_SetString(PyExc_ValueError,
          59                 :            :                     "isolation_level string must be '', 'DEFERRED', "
          60                 :            :                     "'IMMEDIATE', or 'EXCLUSIVE'");
          61                 :          0 :     return NULL;
          62                 :            : }
          63                 :            :
          64                 :            : static int
          65                 :          0 : isolation_level_converter(PyObject *str_or_none, const char **result)
          66                 :            : {
          67         [ #  # ]:          0 :     if (Py_IsNone(str_or_none)) {
          68                 :          0 :         *result = NULL;
          69                 :            :     }
          70         [ #  # ]:          0 :     else if (PyUnicode_Check(str_or_none)) {
          71                 :            :         Py_ssize_t sz;
          72                 :          0 :         const char *str = PyUnicode_AsUTF8AndSize(str_or_none, &sz);
          73         [ #  # ]:          0 :         if (str == NULL) {
          74                 :          0 :             return 0;
          75                 :            :         }
          76         [ #  # ]:          0 :         if (strlen(str) != (size_t)sz) {
          77                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null character");
          78                 :          0 :             return 0;
          79                 :            :         }
          80                 :            :
          81                 :          0 :         const char *level = get_isolation_level(str);
          82         [ #  # ]:          0 :         if (level == NULL) {
          83                 :          0 :             return 0;
          84                 :            :         }
          85                 :          0 :         *result = level;
          86                 :            :     }
          87                 :            :     else {
          88                 :          0 :         PyErr_SetString(PyExc_TypeError,
          89                 :            :                         "isolation_level must be str or None");
          90                 :          0 :         return 0;
          91                 :            :     }
          92                 :          0 :     return 1;
          93                 :            : }
          94                 :            :
          95                 :            : static int
          96                 :          0 : autocommit_converter(PyObject *val, enum autocommit_mode *result)
          97                 :            : {
          98         [ #  # ]:          0 :     if (Py_IsTrue(val)) {
          99                 :          0 :         *result = AUTOCOMMIT_ENABLED;
         100                 :          0 :         return 1;
         101                 :            :     }
         102         [ #  # ]:          0 :     if (Py_IsFalse(val)) {
         103                 :          0 :         *result = AUTOCOMMIT_DISABLED;
         104                 :          0 :         return 1;
         105                 :            :     }
         106   [ #  #  #  # ]:          0 :     if (PyLong_Check(val) &&
         107                 :          0 :         PyLong_AsLong(val) == LEGACY_TRANSACTION_CONTROL)
         108                 :            :     {
         109                 :          0 :         *result = AUTOCOMMIT_LEGACY;
         110                 :          0 :         return 1;
         111                 :            :     }
         112                 :            :
         113                 :          0 :     PyErr_SetString(PyExc_ValueError,
         114                 :            :         "autocommit must be True, False, or "
         115                 :            :         "sqlite3.LEGACY_TRANSACTION_CONTROL");
         116                 :          0 :     return 0;
         117                 :            : }
         118                 :            :
         119                 :            : #define clinic_state() (pysqlite_get_state_by_type(Py_TYPE(self)))
         120                 :            : #include "clinic/connection.c.h"
         121                 :            : #undef clinic_state
         122                 :            :
         123                 :            : /*[clinic input]
         124                 :            : module _sqlite3
         125                 :            : class _sqlite3.Connection "pysqlite_Connection *" "clinic_state()->ConnectionType"
         126                 :            : [clinic start generated code]*/
         127                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=67369db2faf80891]*/
         128                 :            :
         129                 :            : static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self);
         130                 :            : static void free_callback_context(callback_context *ctx);
         131                 :            : static void set_callback_context(callback_context **ctx_pp,
         132                 :            :                                  callback_context *ctx);
         133                 :            : static void connection_close(pysqlite_Connection *self);
         134                 :            : PyObject *_pysqlite_query_execute(pysqlite_Cursor *, int, PyObject *, PyObject *);
         135                 :            :
         136                 :            : static PyObject *
         137                 :          0 : new_statement_cache(pysqlite_Connection *self, pysqlite_state *state,
         138                 :            :                     int maxsize)
         139                 :            : {
         140                 :          0 :     PyObject *args[] = { NULL, PyLong_FromLong(maxsize), };
         141         [ #  # ]:          0 :     if (args[1] == NULL) {
         142                 :          0 :         return NULL;
         143                 :            :     }
         144                 :          0 :     PyObject *lru_cache = state->lru_cache;
         145                 :          0 :     size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
         146                 :          0 :     PyObject *inner = PyObject_Vectorcall(lru_cache, args + 1, nargsf, NULL);
         147                 :          0 :     Py_DECREF(args[1]);
         148         [ #  # ]:          0 :     if (inner == NULL) {
         149                 :          0 :         return NULL;
         150                 :            :     }
         151                 :            :
         152                 :          0 :     args[1] = (PyObject *)self;  // Borrowed ref.
         153                 :          0 :     nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
         154                 :          0 :     PyObject *res = PyObject_Vectorcall(inner, args + 1, nargsf, NULL);
         155                 :          0 :     Py_DECREF(inner);
         156                 :          0 :     return res;
         157                 :            : }
         158                 :            :
         159                 :            : static inline int
         160                 :          0 : connection_exec_stmt(pysqlite_Connection *self, const char *sql)
         161                 :            : {
         162                 :            :     int rc;
         163                 :          0 :     Py_BEGIN_ALLOW_THREADS
         164                 :          0 :     int len = (int)strlen(sql) + 1;
         165                 :            :     sqlite3_stmt *stmt;
         166                 :          0 :     rc = sqlite3_prepare_v2(self->db, sql, len, &stmt, NULL);
         167         [ #  # ]:          0 :     if (rc == SQLITE_OK) {
         168                 :          0 :         (void)sqlite3_step(stmt);
         169                 :          0 :         rc = sqlite3_finalize(stmt);
         170                 :            :     }
         171                 :          0 :     Py_END_ALLOW_THREADS
         172                 :            :
         173         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
         174                 :          0 :         (void)_pysqlite_seterror(self->state, self->db);
         175                 :          0 :         return -1;
         176                 :            :     }
         177                 :          0 :     return 0;
         178                 :            : }
         179                 :            :
         180                 :            : /*[python input]
         181                 :            : class IsolationLevel_converter(CConverter):
         182                 :            :     type = "const char *"
         183                 :            :     converter = "isolation_level_converter"
         184                 :            :
         185                 :            : class Autocommit_converter(CConverter):
         186                 :            :     type = "enum autocommit_mode"
         187                 :            :     converter = "autocommit_converter"
         188                 :            :
         189                 :            : [python start generated code]*/
         190                 :            : /*[python end generated code: output=da39a3ee5e6b4b0d input=bc2aa6c7ba0c5f8f]*/
         191                 :            :
         192                 :            : // NB: This needs to be in sync with the sqlite3.connect docstring
         193                 :            : /*[clinic input]
         194                 :            : _sqlite3.Connection.__init__ as pysqlite_connection_init
         195                 :            :
         196                 :            :     database: object
         197                 :            :     timeout: double = 5.0
         198                 :            :     detect_types: int = 0
         199                 :            :     isolation_level: IsolationLevel = ""
         200                 :            :     check_same_thread: bool = True
         201                 :            :     factory: object(c_default='(PyObject*)clinic_state()->ConnectionType') = ConnectionType
         202                 :            :     cached_statements as cache_size: int = 128
         203                 :            :     uri: bool = False
         204                 :            :     *
         205                 :            :     autocommit: Autocommit(c_default='LEGACY_TRANSACTION_CONTROL') = sqlite3.LEGACY_TRANSACTION_CONTROL
         206                 :            : [clinic start generated code]*/
         207                 :            :
         208                 :            : static int
         209                 :          0 : pysqlite_connection_init_impl(pysqlite_Connection *self, PyObject *database,
         210                 :            :                               double timeout, int detect_types,
         211                 :            :                               const char *isolation_level,
         212                 :            :                               int check_same_thread, PyObject *factory,
         213                 :            :                               int cache_size, int uri,
         214                 :            :                               enum autocommit_mode autocommit)
         215                 :            : /*[clinic end generated code: output=cba057313ea7712f input=9b0ab6c12f674fa3]*/
         216                 :            : {
         217         [ #  # ]:          0 :     if (PySys_Audit("sqlite3.connect", "O", database) < 0) {
         218                 :          0 :         return -1;
         219                 :            :     }
         220                 :            :
         221                 :            :     PyObject *bytes;
         222         [ #  # ]:          0 :     if (!PyUnicode_FSConverter(database, &bytes)) {
         223                 :          0 :         return -1;
         224                 :            :     }
         225                 :            :
         226         [ #  # ]:          0 :     if (self->initialized) {
         227                 :          0 :         PyTypeObject *tp = Py_TYPE(self);
         228                 :          0 :         tp->tp_clear((PyObject *)self);
         229                 :          0 :         connection_close(self);
         230                 :          0 :         self->initialized = 0;
         231                 :            :     }
         232                 :            :
         233                 :            :     // Create and configure SQLite database object.
         234                 :            :     sqlite3 *db;
         235                 :            :     int rc;
         236                 :          0 :     Py_BEGIN_ALLOW_THREADS
         237         [ #  # ]:          0 :     rc = sqlite3_open_v2(PyBytes_AS_STRING(bytes), &db,
         238                 :            :                          SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
         239                 :            :                          (uri ? SQLITE_OPEN_URI : 0), NULL);
         240         [ #  # ]:          0 :     if (rc == SQLITE_OK) {
         241                 :          0 :         (void)sqlite3_busy_timeout(db, (int)(timeout*1000));
         242                 :            :     }
         243                 :          0 :     Py_END_ALLOW_THREADS
         244                 :            :
         245                 :          0 :     Py_DECREF(bytes);
         246   [ #  #  #  # ]:          0 :     if (db == NULL && rc == SQLITE_NOMEM) {
         247                 :          0 :         PyErr_NoMemory();
         248                 :          0 :         return -1;
         249                 :            :     }
         250                 :            :
         251                 :          0 :     pysqlite_state *state = pysqlite_get_state_by_type(Py_TYPE(self));
         252         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
         253                 :          0 :         _pysqlite_seterror(state, db);
         254                 :          0 :         goto error;
         255                 :            :     }
         256                 :            :
         257                 :            :     // Create LRU statement cache; returns a new reference.
         258                 :          0 :     PyObject *statement_cache = new_statement_cache(self, state, cache_size);
         259         [ #  # ]:          0 :     if (statement_cache == NULL) {
         260                 :          0 :         goto error;
         261                 :            :     }
         262                 :            :
         263                 :            :     /* Create lists of weak references to cursors and blobs */
         264                 :          0 :     PyObject *cursors = PyList_New(0);
         265         [ #  # ]:          0 :     if (cursors == NULL) {
         266                 :          0 :         Py_DECREF(statement_cache);
         267                 :          0 :         goto error;
         268                 :            :     }
         269                 :            :
         270                 :          0 :     PyObject *blobs = PyList_New(0);
         271         [ #  # ]:          0 :     if (blobs == NULL) {
         272                 :          0 :         Py_DECREF(statement_cache);
         273                 :          0 :         Py_DECREF(cursors);
         274                 :          0 :         goto error;
         275                 :            :     }
         276                 :            :
         277                 :            :     // Init connection state members.
         278                 :          0 :     self->db = db;
         279                 :          0 :     self->state = state;
         280                 :          0 :     self->detect_types = detect_types;
         281                 :          0 :     self->isolation_level = isolation_level;
         282                 :          0 :     self->autocommit = autocommit;
         283                 :          0 :     self->check_same_thread = check_same_thread;
         284                 :          0 :     self->thread_ident = PyThread_get_thread_ident();
         285                 :          0 :     self->statement_cache = statement_cache;
         286                 :          0 :     self->cursors = cursors;
         287                 :          0 :     self->blobs = blobs;
         288                 :          0 :     self->created_cursors = 0;
         289                 :          0 :     self->row_factory = Py_NewRef(Py_None);
         290                 :          0 :     self->text_factory = Py_NewRef(&PyUnicode_Type);
         291                 :          0 :     self->trace_ctx = NULL;
         292                 :          0 :     self->progress_ctx = NULL;
         293                 :          0 :     self->authorizer_ctx = NULL;
         294                 :            :
         295                 :            :     // Borrowed refs
         296                 :          0 :     self->Warning               = state->Warning;
         297                 :          0 :     self->Error                 = state->Error;
         298                 :          0 :     self->InterfaceError        = state->InterfaceError;
         299                 :          0 :     self->DatabaseError         = state->DatabaseError;
         300                 :          0 :     self->DataError             = state->DataError;
         301                 :          0 :     self->OperationalError      = state->OperationalError;
         302                 :          0 :     self->IntegrityError        = state->IntegrityError;
         303                 :          0 :     self->InternalError         = state->InternalError;
         304                 :          0 :     self->ProgrammingError      = state->ProgrammingError;
         305                 :          0 :     self->NotSupportedError     = state->NotSupportedError;
         306                 :            :
         307         [ #  # ]:          0 :     if (PySys_Audit("sqlite3.connect/handle", "O", self) < 0) {
         308                 :          0 :         return -1;  // Don't goto error; at this point, dealloc will clean up.
         309                 :            :     }
         310                 :            :
         311                 :          0 :     self->initialized = 1;
         312                 :            :
         313         [ #  # ]:          0 :     if (autocommit == AUTOCOMMIT_DISABLED) {
         314                 :          0 :         (void)connection_exec_stmt(self, "BEGIN");
         315                 :            :     }
         316                 :          0 :     return 0;
         317                 :            :
         318                 :          0 : error:
         319                 :            :     // There are no statements or other SQLite objects attached to the
         320                 :            :     // database, so sqlite3_close() should always return SQLITE_OK.
         321                 :          0 :     rc = sqlite3_close(db);
         322                 :            :     assert(rc == SQLITE_OK);
         323                 :          0 :     return -1;
         324                 :            : }
         325                 :            :
         326                 :            : #define VISIT_CALLBACK_CONTEXT(ctx) \
         327                 :            : do {                                \
         328                 :            :     if (ctx) {                      \
         329                 :            :         Py_VISIT(ctx->callable);    \
         330                 :            :         Py_VISIT(ctx->module);      \
         331                 :            :     }                               \
         332                 :            : } while (0)
         333                 :            :
         334                 :            : static int
         335                 :          0 : connection_traverse(pysqlite_Connection *self, visitproc visit, void *arg)
         336                 :            : {
         337   [ #  #  #  # ]:          0 :     Py_VISIT(Py_TYPE(self));
         338   [ #  #  #  # ]:          0 :     Py_VISIT(self->statement_cache);
         339   [ #  #  #  # ]:          0 :     Py_VISIT(self->cursors);
         340   [ #  #  #  # ]:          0 :     Py_VISIT(self->blobs);
         341   [ #  #  #  # ]:          0 :     Py_VISIT(self->row_factory);
         342   [ #  #  #  # ]:          0 :     Py_VISIT(self->text_factory);
         343   [ #  #  #  #  :          0 :     VISIT_CALLBACK_CONTEXT(self->trace_ctx);
              #  #  #  #  #
                          # ]
         344   [ #  #  #  #  :          0 :     VISIT_CALLBACK_CONTEXT(self->progress_ctx);
              #  #  #  #  #
                          # ]
         345   [ #  #  #  #  :          0 :     VISIT_CALLBACK_CONTEXT(self->authorizer_ctx);
              #  #  #  #  #
                          # ]
         346                 :            : #undef VISIT_CALLBACK_CONTEXT
         347                 :          0 :     return 0;
         348                 :            : }
         349                 :            :
         350                 :            : static inline void
         351                 :          0 : clear_callback_context(callback_context *ctx)
         352                 :            : {
         353         [ #  # ]:          0 :     if (ctx != NULL) {
         354         [ #  # ]:          0 :         Py_CLEAR(ctx->callable);
         355         [ #  # ]:          0 :         Py_CLEAR(ctx->module);
         356                 :            :     }
         357                 :          0 : }
         358                 :            :
         359                 :            : static int
         360                 :          0 : connection_clear(pysqlite_Connection *self)
         361                 :            : {
         362         [ #  # ]:          0 :     Py_CLEAR(self->statement_cache);
         363         [ #  # ]:          0 :     Py_CLEAR(self->cursors);
         364         [ #  # ]:          0 :     Py_CLEAR(self->blobs);
         365         [ #  # ]:          0 :     Py_CLEAR(self->row_factory);
         366         [ #  # ]:          0 :     Py_CLEAR(self->text_factory);
         367                 :          0 :     clear_callback_context(self->trace_ctx);
         368                 :          0 :     clear_callback_context(self->progress_ctx);
         369                 :          0 :     clear_callback_context(self->authorizer_ctx);
         370                 :          0 :     return 0;
         371                 :            : }
         372                 :            :
         373                 :            : static void
         374                 :          0 : free_callback_contexts(pysqlite_Connection *self)
         375                 :            : {
         376                 :          0 :     set_callback_context(&self->trace_ctx, NULL);
         377                 :          0 :     set_callback_context(&self->progress_ctx, NULL);
         378                 :          0 :     set_callback_context(&self->authorizer_ctx, NULL);
         379                 :          0 : }
         380                 :            :
         381                 :            : static void
         382                 :          0 : remove_callbacks(sqlite3 *db)
         383                 :            : {
         384                 :            : #ifdef HAVE_TRACE_V2
         385                 :          0 :     sqlite3_trace_v2(db, SQLITE_TRACE_STMT, 0, 0);
         386                 :            : #else
         387                 :            :     sqlite3_trace(db, 0, (void*)0);
         388                 :            : #endif
         389                 :          0 :     sqlite3_progress_handler(db, 0, 0, (void *)0);
         390                 :          0 :     (void)sqlite3_set_authorizer(db, NULL, NULL);
         391                 :          0 : }
         392                 :            :
         393                 :            : static void
         394                 :          0 : connection_close(pysqlite_Connection *self)
         395                 :            : {
         396         [ #  # ]:          0 :     if (self->db) {
         397   [ #  #  #  # ]:          0 :         if (self->autocommit == AUTOCOMMIT_DISABLED &&
         398                 :          0 :             !sqlite3_get_autocommit(self->db))
         399                 :            :         {
         400                 :            :             /* If close is implicitly called as a result of interpreter
         401                 :            :              * tear-down, we must not call back into Python. */
         402         [ #  # ]:          0 :             if (_Py_IsFinalizing()) {
         403                 :          0 :                 remove_callbacks(self->db);
         404                 :            :             }
         405                 :          0 :             (void)connection_exec_stmt(self, "ROLLBACK");
         406                 :            :         }
         407                 :            :
         408                 :          0 :         free_callback_contexts(self);
         409                 :            :
         410                 :          0 :         sqlite3 *db = self->db;
         411                 :          0 :         self->db = NULL;
         412                 :            :
         413                 :          0 :         Py_BEGIN_ALLOW_THREADS
         414                 :          0 :         int rc = sqlite3_close_v2(db);
         415                 :            :         assert(rc == SQLITE_OK), (void)rc;
         416                 :          0 :         Py_END_ALLOW_THREADS
         417                 :            :     }
         418                 :          0 : }
         419                 :            :
         420                 :            : static void
         421                 :          0 : connection_dealloc(pysqlite_Connection *self)
         422                 :            : {
         423                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
         424                 :          0 :     PyObject_GC_UnTrack(self);
         425                 :          0 :     tp->tp_clear((PyObject *)self);
         426                 :            :
         427                 :            :     /* Clean up if user has not called .close() explicitly. */
         428                 :          0 :     connection_close(self);
         429                 :            :
         430                 :          0 :     tp->tp_free(self);
         431                 :          0 :     Py_DECREF(tp);
         432                 :          0 : }
         433                 :            :
         434                 :            : /*[clinic input]
         435                 :            : _sqlite3.Connection.cursor as pysqlite_connection_cursor
         436                 :            :
         437                 :            :     factory: object = NULL
         438                 :            :
         439                 :            : Return a cursor for the connection.
         440                 :            : [clinic start generated code]*/
         441                 :            :
         442                 :            : static PyObject *
         443                 :          0 : pysqlite_connection_cursor_impl(pysqlite_Connection *self, PyObject *factory)
         444                 :            : /*[clinic end generated code: output=562432a9e6af2aa1 input=4127345aa091b650]*/
         445                 :            : {
         446                 :            :     PyObject* cursor;
         447                 :            :
         448   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
         449                 :          0 :         return NULL;
         450                 :            :     }
         451                 :            :
         452         [ #  # ]:          0 :     if (factory == NULL) {
         453                 :          0 :         factory = (PyObject *)self->state->CursorType;
         454                 :            :     }
         455                 :            :
         456                 :          0 :     cursor = PyObject_CallOneArg(factory, (PyObject *)self);
         457         [ #  # ]:          0 :     if (cursor == NULL)
         458                 :          0 :         return NULL;
         459         [ #  # ]:          0 :     if (!PyObject_TypeCheck(cursor, self->state->CursorType)) {
         460                 :          0 :         PyErr_Format(PyExc_TypeError,
         461                 :            :                      "factory must return a cursor, not %.100s",
         462                 :          0 :                      Py_TYPE(cursor)->tp_name);
         463                 :          0 :         Py_DECREF(cursor);
         464                 :          0 :         return NULL;
         465                 :            :     }
         466                 :            :
         467                 :          0 :     _pysqlite_drop_unused_cursor_references(self);
         468                 :            :
         469   [ #  #  #  # ]:          0 :     if (cursor && self->row_factory != Py_None) {
         470                 :          0 :         Py_INCREF(self->row_factory);
         471                 :          0 :         Py_XSETREF(((pysqlite_Cursor *)cursor)->row_factory, self->row_factory);
         472                 :            :     }
         473                 :            :
         474                 :          0 :     return cursor;
         475                 :            : }
         476                 :            :
         477                 :            : /*[clinic input]
         478                 :            : _sqlite3.Connection.blobopen as blobopen
         479                 :            :
         480                 :            :     table: str
         481                 :            :         Table name.
         482                 :            :     column as col: str
         483                 :            :         Column name.
         484                 :            :     row: int
         485                 :            :         Row index.
         486                 :            :     /
         487                 :            :     *
         488                 :            :     readonly: bool = False
         489                 :            :         Open the BLOB without write permissions.
         490                 :            :     name: str = "main"
         491                 :            :         Database name.
         492                 :            :
         493                 :            : Open and return a BLOB object.
         494                 :            : [clinic start generated code]*/
         495                 :            :
         496                 :            : static PyObject *
         497                 :          0 : blobopen_impl(pysqlite_Connection *self, const char *table, const char *col,
         498                 :            :               int row, int readonly, const char *name)
         499                 :            : /*[clinic end generated code: output=0c8e2e58516d0b5c input=fa73c83aa7a7ddee]*/
         500                 :            : {
         501   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
         502                 :          0 :         return NULL;
         503                 :            :     }
         504                 :            :
         505                 :            :     int rc;
         506                 :            :     sqlite3_blob *blob;
         507                 :            :
         508                 :          0 :     Py_BEGIN_ALLOW_THREADS
         509                 :          0 :     rc = sqlite3_blob_open(self->db, name, table, col, row, !readonly, &blob);
         510                 :          0 :     Py_END_ALLOW_THREADS
         511                 :            :
         512         [ #  # ]:          0 :     if (rc == SQLITE_MISUSE) {
         513                 :          0 :         PyErr_Format(self->state->InterfaceError, sqlite3_errstr(rc));
         514                 :          0 :         return NULL;
         515                 :            :     }
         516         [ #  # ]:          0 :     else if (rc != SQLITE_OK) {
         517                 :          0 :         _pysqlite_seterror(self->state, self->db);
         518                 :          0 :         return NULL;
         519                 :            :     }
         520                 :            :
         521                 :          0 :     pysqlite_Blob *obj = PyObject_GC_New(pysqlite_Blob, self->state->BlobType);
         522         [ #  # ]:          0 :     if (obj == NULL) {
         523                 :          0 :         goto error;
         524                 :            :     }
         525                 :            :
         526                 :          0 :     obj->connection = (pysqlite_Connection *)Py_NewRef(self);
         527                 :          0 :     obj->blob = blob;
         528                 :          0 :     obj->offset = 0;
         529                 :          0 :     obj->in_weakreflist = NULL;
         530                 :            :
         531                 :          0 :     PyObject_GC_Track(obj);
         532                 :            :
         533                 :            :     // Add our blob to connection blobs list
         534                 :          0 :     PyObject *weakref = PyWeakref_NewRef((PyObject *)obj, NULL);
         535         [ #  # ]:          0 :     if (weakref == NULL) {
         536                 :          0 :         goto error;
         537                 :            :     }
         538                 :          0 :     rc = PyList_Append(self->blobs, weakref);
         539                 :          0 :     Py_DECREF(weakref);
         540         [ #  # ]:          0 :     if (rc < 0) {
         541                 :          0 :         goto error;
         542                 :            :     }
         543                 :            :
         544                 :          0 :     return (PyObject *)obj;
         545                 :            :
         546                 :          0 : error:
         547                 :          0 :     Py_XDECREF(obj);
         548                 :          0 :     return NULL;
         549                 :            : }
         550                 :            :
         551                 :            : /*[clinic input]
         552                 :            : _sqlite3.Connection.close as pysqlite_connection_close
         553                 :            :
         554                 :            : Close the database connection.
         555                 :            :
         556                 :            : Any pending transaction is not committed implicitly.
         557                 :            : [clinic start generated code]*/
         558                 :            :
         559                 :            : static PyObject *
         560                 :          0 : pysqlite_connection_close_impl(pysqlite_Connection *self)
         561                 :            : /*[clinic end generated code: output=a546a0da212c9b97 input=b3ed5b74f6fefc06]*/
         562                 :            : {
         563         [ #  # ]:          0 :     if (!pysqlite_check_thread(self)) {
         564                 :          0 :         return NULL;
         565                 :            :     }
         566                 :            :
         567         [ #  # ]:          0 :     if (!self->initialized) {
         568                 :          0 :         PyTypeObject *tp = Py_TYPE(self);
         569                 :          0 :         pysqlite_state *state = pysqlite_get_state_by_type(tp);
         570                 :          0 :         PyErr_SetString(state->ProgrammingError,
         571                 :            :                         "Base Connection.__init__ not called.");
         572                 :          0 :         return NULL;
         573                 :            :     }
         574                 :            :
         575                 :          0 :     pysqlite_close_all_blobs(self);
         576         [ #  # ]:          0 :     Py_CLEAR(self->statement_cache);
         577                 :          0 :     connection_close(self);
         578                 :            :
         579                 :          0 :     Py_RETURN_NONE;
         580                 :            : }
         581                 :            :
         582                 :            : /*
         583                 :            :  * Checks if a connection object is usable (i. e. not closed).
         584                 :            :  *
         585                 :            :  * 0 => error; 1 => ok
         586                 :            :  */
         587                 :          0 : int pysqlite_check_connection(pysqlite_Connection* con)
         588                 :            : {
         589         [ #  # ]:          0 :     if (!con->initialized) {
         590                 :          0 :         pysqlite_state *state = pysqlite_get_state_by_type(Py_TYPE(con));
         591                 :          0 :         PyErr_SetString(state->ProgrammingError,
         592                 :            :                         "Base Connection.__init__ not called.");
         593                 :          0 :         return 0;
         594                 :            :     }
         595                 :            :
         596         [ #  # ]:          0 :     if (!con->db) {
         597                 :          0 :         PyErr_SetString(con->state->ProgrammingError,
         598                 :            :                         "Cannot operate on a closed database.");
         599                 :          0 :         return 0;
         600                 :            :     } else {
         601                 :          0 :         return 1;
         602                 :            :     }
         603                 :            : }
         604                 :            :
         605                 :            : /*[clinic input]
         606                 :            : _sqlite3.Connection.commit as pysqlite_connection_commit
         607                 :            :
         608                 :            : Commit any pending transaction to the database.
         609                 :            :
         610                 :            : If there is no open transaction, this method is a no-op.
         611                 :            : [clinic start generated code]*/
         612                 :            :
         613                 :            : static PyObject *
         614                 :          0 : pysqlite_connection_commit_impl(pysqlite_Connection *self)
         615                 :            : /*[clinic end generated code: output=3da45579e89407f2 input=c8793c97c3446065]*/
         616                 :            : {
         617   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
         618                 :          0 :         return NULL;
         619                 :            :     }
         620                 :            :
         621         [ #  # ]:          0 :     if (self->autocommit == AUTOCOMMIT_LEGACY) {
         622         [ #  # ]:          0 :         if (!sqlite3_get_autocommit(self->db)) {
         623         [ #  # ]:          0 :             if (connection_exec_stmt(self, "COMMIT") < 0) {
         624                 :          0 :                 return NULL;
         625                 :            :             }
         626                 :            :         }
         627                 :            :     }
         628         [ #  # ]:          0 :     else if (self->autocommit == AUTOCOMMIT_DISABLED) {
         629         [ #  # ]:          0 :         if (connection_exec_stmt(self, "COMMIT") < 0) {
         630                 :          0 :             return NULL;
         631                 :            :         }
         632         [ #  # ]:          0 :         if (connection_exec_stmt(self, "BEGIN") < 0) {
         633                 :          0 :             return NULL;
         634                 :            :         }
         635                 :            :     }
         636                 :          0 :     Py_RETURN_NONE;
         637                 :            : }
         638                 :            :
         639                 :            : /*[clinic input]
         640                 :            : _sqlite3.Connection.rollback as pysqlite_connection_rollback
         641                 :            :
         642                 :            : Roll back to the start of any pending transaction.
         643                 :            :
         644                 :            : If there is no open transaction, this method is a no-op.
         645                 :            : [clinic start generated code]*/
         646                 :            :
         647                 :            : static PyObject *
         648                 :          0 : pysqlite_connection_rollback_impl(pysqlite_Connection *self)
         649                 :            : /*[clinic end generated code: output=b66fa0d43e7ef305 input=7f60a2f1076f16b3]*/
         650                 :            : {
         651   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
         652                 :          0 :         return NULL;
         653                 :            :     }
         654                 :            :
         655         [ #  # ]:          0 :     if (self->autocommit == AUTOCOMMIT_LEGACY) {
         656         [ #  # ]:          0 :         if (!sqlite3_get_autocommit(self->db)) {
         657         [ #  # ]:          0 :             if (connection_exec_stmt(self, "ROLLBACK") < 0) {
         658                 :          0 :                 return NULL;
         659                 :            :             }
         660                 :            :         }
         661                 :            :     }
         662         [ #  # ]:          0 :     else if (self->autocommit == AUTOCOMMIT_DISABLED) {
         663         [ #  # ]:          0 :         if (connection_exec_stmt(self, "ROLLBACK") < 0) {
         664                 :          0 :             return NULL;
         665                 :            :         }
         666         [ #  # ]:          0 :         if (connection_exec_stmt(self, "BEGIN") < 0) {
         667                 :          0 :             return NULL;
         668                 :            :         }
         669                 :            :     }
         670                 :          0 :     Py_RETURN_NONE;
         671                 :            : }
         672                 :            :
         673                 :            : static int
         674                 :          0 : _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)
         675                 :            : {
         676         [ #  # ]:          0 :     if (py_val == Py_None) {
         677                 :          0 :         sqlite3_result_null(context);
         678         [ #  # ]:          0 :     } else if (PyLong_Check(py_val)) {
         679                 :          0 :         sqlite_int64 value = _pysqlite_long_as_int64(py_val);
         680   [ #  #  #  # ]:          0 :         if (value == -1 && PyErr_Occurred())
         681                 :          0 :             return -1;
         682                 :          0 :         sqlite3_result_int64(context, value);
         683         [ #  # ]:          0 :     } else if (PyFloat_Check(py_val)) {
         684                 :          0 :         double value = PyFloat_AsDouble(py_val);
         685   [ #  #  #  # ]:          0 :         if (value == -1 && PyErr_Occurred()) {
         686                 :          0 :             return -1;
         687                 :            :         }
         688                 :          0 :         sqlite3_result_double(context, value);
         689         [ #  # ]:          0 :     } else if (PyUnicode_Check(py_val)) {
         690                 :            :         Py_ssize_t sz;
         691                 :          0 :         const char *str = PyUnicode_AsUTF8AndSize(py_val, &sz);
         692         [ #  # ]:          0 :         if (str == NULL) {
         693                 :          0 :             return -1;
         694                 :            :         }
         695         [ #  # ]:          0 :         if (sz > INT_MAX) {
         696                 :          0 :             PyErr_SetString(PyExc_OverflowError,
         697                 :            :                             "string is longer than INT_MAX bytes");
         698                 :          0 :             return -1;
         699                 :            :         }
         700                 :          0 :         sqlite3_result_text(context, str, (int)sz, SQLITE_TRANSIENT);
         701         [ #  # ]:          0 :     } else if (PyObject_CheckBuffer(py_val)) {
         702                 :            :         Py_buffer view;
         703         [ #  # ]:          0 :         if (PyObject_GetBuffer(py_val, &view, PyBUF_SIMPLE) != 0) {
         704                 :          0 :             return -1;
         705                 :            :         }
         706         [ #  # ]:          0 :         if (view.len > INT_MAX) {
         707                 :          0 :             PyErr_SetString(PyExc_OverflowError,
         708                 :            :                             "BLOB longer than INT_MAX bytes");
         709                 :          0 :             PyBuffer_Release(&view);
         710                 :          0 :             return -1;
         711                 :            :         }
         712                 :          0 :         sqlite3_result_blob(context, view.buf, (int)view.len, SQLITE_TRANSIENT);
         713                 :          0 :         PyBuffer_Release(&view);
         714                 :            :     } else {
         715                 :          0 :         callback_context *ctx = (callback_context *)sqlite3_user_data(context);
         716                 :          0 :         PyErr_Format(ctx->state->ProgrammingError,
         717                 :            :                      "User-defined functions cannot return '%s' values to "
         718                 :            :                      "SQLite",
         719                 :          0 :                      Py_TYPE(py_val)->tp_name);
         720                 :          0 :         return -1;
         721                 :            :     }
         722                 :          0 :     return 0;
         723                 :            : }
         724                 :            :
         725                 :            : static PyObject *
         726                 :          0 : _pysqlite_build_py_params(sqlite3_context *context, int argc,
         727                 :            :                           sqlite3_value **argv)
         728                 :            : {
         729                 :            :     PyObject* args;
         730                 :            :     int i;
         731                 :            :     sqlite3_value* cur_value;
         732                 :            :     PyObject* cur_py_value;
         733                 :            :
         734                 :          0 :     args = PyTuple_New(argc);
         735         [ #  # ]:          0 :     if (!args) {
         736                 :          0 :         return NULL;
         737                 :            :     }
         738                 :            :
         739         [ #  # ]:          0 :     for (i = 0; i < argc; i++) {
         740                 :          0 :         cur_value = argv[i];
         741   [ #  #  #  #  :          0 :         switch (sqlite3_value_type(argv[i])) {
                          # ]
         742                 :          0 :             case SQLITE_INTEGER:
         743                 :          0 :                 cur_py_value = PyLong_FromLongLong(sqlite3_value_int64(cur_value));
         744                 :          0 :                 break;
         745                 :          0 :             case SQLITE_FLOAT:
         746                 :          0 :                 cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));
         747                 :          0 :                 break;
         748                 :          0 :             case SQLITE_TEXT: {
         749                 :          0 :                 sqlite3 *db = sqlite3_context_db_handle(context);
         750                 :          0 :                 const char *text = (const char *)sqlite3_value_text(cur_value);
         751                 :            :
         752   [ #  #  #  # ]:          0 :                 if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
         753                 :          0 :                     PyErr_NoMemory();
         754                 :          0 :                     goto error;
         755                 :            :                 }
         756                 :            :
         757                 :          0 :                 Py_ssize_t size = sqlite3_value_bytes(cur_value);
         758                 :          0 :                 cur_py_value = PyUnicode_FromStringAndSize(text, size);
         759                 :          0 :                 break;
         760                 :            :             }
         761                 :          0 :             case SQLITE_BLOB: {
         762                 :          0 :                 sqlite3 *db = sqlite3_context_db_handle(context);
         763                 :          0 :                 const void *blob = sqlite3_value_blob(cur_value);
         764                 :            :
         765   [ #  #  #  # ]:          0 :                 if (blob == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
         766                 :          0 :                     PyErr_NoMemory();
         767                 :          0 :                     goto error;
         768                 :            :                 }
         769                 :            :
         770                 :          0 :                 Py_ssize_t size = sqlite3_value_bytes(cur_value);
         771                 :          0 :                 cur_py_value = PyBytes_FromStringAndSize(blob, size);
         772                 :          0 :                 break;
         773                 :            :             }
         774                 :          0 :             case SQLITE_NULL:
         775                 :            :             default:
         776                 :          0 :                 cur_py_value = Py_NewRef(Py_None);
         777                 :            :         }
         778                 :            :
         779         [ #  # ]:          0 :         if (!cur_py_value) {
         780                 :          0 :             goto error;
         781                 :            :         }
         782                 :            :
         783                 :          0 :         PyTuple_SET_ITEM(args, i, cur_py_value);
         784                 :            :     }
         785                 :            :
         786                 :          0 :     return args;
         787                 :            :
         788                 :          0 : error:
         789                 :          0 :     Py_DECREF(args);
         790                 :          0 :     return NULL;
         791                 :            : }
         792                 :            :
         793                 :            : static void
         794                 :          0 : print_or_clear_traceback(callback_context *ctx)
         795                 :            : {
         796                 :            :     assert(ctx != NULL);
         797                 :            :     assert(ctx->state != NULL);
         798         [ #  # ]:          0 :     if (ctx->state->enable_callback_tracebacks) {
         799                 :          0 :         PyErr_WriteUnraisable(ctx->callable);
         800                 :            :     }
         801                 :            :     else {
         802                 :          0 :         PyErr_Clear();
         803                 :            :     }
         804                 :          0 : }
         805                 :            :
         806                 :            : // Checks the Python exception and sets the appropriate SQLite error code.
         807                 :            : static void
         808                 :          0 : set_sqlite_error(sqlite3_context *context, const char *msg)
         809                 :            : {
         810                 :            :     assert(PyErr_Occurred());
         811         [ #  # ]:          0 :     if (PyErr_ExceptionMatches(PyExc_MemoryError)) {
         812                 :          0 :         sqlite3_result_error_nomem(context);
         813                 :            :     }
         814         [ #  # ]:          0 :     else if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
         815                 :          0 :         sqlite3_result_error_toobig(context);
         816                 :            :     }
         817                 :            :     else {
         818                 :          0 :         sqlite3_result_error(context, msg, -1);
         819                 :            :     }
         820                 :          0 :     callback_context *ctx = (callback_context *)sqlite3_user_data(context);
         821                 :          0 :     print_or_clear_traceback(ctx);
         822                 :          0 : }
         823                 :            :
         824                 :            : static void
         825                 :          0 : func_callback(sqlite3_context *context, int argc, sqlite3_value **argv)
         826                 :            : {
         827                 :          0 :     PyGILState_STATE threadstate = PyGILState_Ensure();
         828                 :            :
         829                 :            :     PyObject* args;
         830                 :          0 :     PyObject* py_retval = NULL;
         831                 :            :     int ok;
         832                 :            :
         833                 :          0 :     args = _pysqlite_build_py_params(context, argc, argv);
         834         [ #  # ]:          0 :     if (args) {
         835                 :          0 :         callback_context *ctx = (callback_context *)sqlite3_user_data(context);
         836                 :            :         assert(ctx != NULL);
         837                 :          0 :         py_retval = PyObject_CallObject(ctx->callable, args);
         838                 :          0 :         Py_DECREF(args);
         839                 :            :     }
         840                 :            :
         841                 :          0 :     ok = 0;
         842         [ #  # ]:          0 :     if (py_retval) {
         843                 :          0 :         ok = _pysqlite_set_result(context, py_retval) == 0;
         844                 :          0 :         Py_DECREF(py_retval);
         845                 :            :     }
         846         [ #  # ]:          0 :     if (!ok) {
         847                 :          0 :         set_sqlite_error(context, "user-defined function raised exception");
         848                 :            :     }
         849                 :            :
         850                 :          0 :     PyGILState_Release(threadstate);
         851                 :          0 : }
         852                 :            :
         853                 :            : static void
         854                 :          0 : step_callback(sqlite3_context *context, int argc, sqlite3_value **params)
         855                 :            : {
         856                 :          0 :     PyGILState_STATE threadstate = PyGILState_Ensure();
         857                 :            :
         858                 :            :     PyObject* args;
         859                 :          0 :     PyObject* function_result = NULL;
         860                 :            :     PyObject** aggregate_instance;
         861                 :          0 :     PyObject* stepmethod = NULL;
         862                 :            :
         863                 :          0 :     callback_context *ctx = (callback_context *)sqlite3_user_data(context);
         864                 :            :     assert(ctx != NULL);
         865                 :            :
         866                 :          0 :     aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
         867         [ #  # ]:          0 :     if (*aggregate_instance == NULL) {
         868                 :          0 :         *aggregate_instance = PyObject_CallNoArgs(ctx->callable);
         869         [ #  # ]:          0 :         if (!*aggregate_instance) {
         870                 :          0 :             set_sqlite_error(context,
         871                 :            :                     "user-defined aggregate's '__init__' method raised error");
         872                 :          0 :             goto error;
         873                 :            :         }
         874                 :            :     }
         875                 :            :
         876                 :          0 :     stepmethod = PyObject_GetAttr(*aggregate_instance, ctx->state->str_step);
         877         [ #  # ]:          0 :     if (!stepmethod) {
         878                 :          0 :         set_sqlite_error(context,
         879                 :            :                 "user-defined aggregate's 'step' method not defined");
         880                 :          0 :         goto error;
         881                 :            :     }
         882                 :            :
         883                 :          0 :     args = _pysqlite_build_py_params(context, argc, params);
         884         [ #  # ]:          0 :     if (!args) {
         885                 :          0 :         goto error;
         886                 :            :     }
         887                 :            :
         888                 :          0 :     function_result = PyObject_CallObject(stepmethod, args);
         889                 :          0 :     Py_DECREF(args);
         890                 :            :
         891         [ #  # ]:          0 :     if (!function_result) {
         892                 :          0 :         set_sqlite_error(context,
         893                 :            :                 "user-defined aggregate's 'step' method raised error");
         894                 :            :     }
         895                 :            :
         896                 :          0 : error:
         897                 :          0 :     Py_XDECREF(stepmethod);
         898                 :          0 :     Py_XDECREF(function_result);
         899                 :            :
         900                 :          0 :     PyGILState_Release(threadstate);
         901                 :          0 : }
         902                 :            :
         903                 :            : static void
         904                 :          0 : final_callback(sqlite3_context *context)
         905                 :            : {
         906                 :          0 :     PyGILState_STATE threadstate = PyGILState_Ensure();
         907                 :            :
         908                 :            :     PyObject* function_result;
         909                 :            :     PyObject** aggregate_instance;
         910                 :            :     int ok;
         911                 :            :
         912                 :          0 :     aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, 0);
         913         [ #  # ]:          0 :     if (aggregate_instance == NULL) {
         914                 :            :         /* No rows matched the query; the step handler was never called. */
         915                 :          0 :         goto error;
         916                 :            :     }
         917         [ #  # ]:          0 :     else if (!*aggregate_instance) {
         918                 :            :         /* this branch is executed if there was an exception in the aggregate's
         919                 :            :          * __init__ */
         920                 :            :
         921                 :          0 :         goto error;
         922                 :            :     }
         923                 :            :
         924                 :            :     // Keep the exception (if any) of the last call to step, value, or inverse
         925                 :          0 :     PyObject *exc = PyErr_GetRaisedException();
         926                 :            :
         927                 :          0 :     callback_context *ctx = (callback_context *)sqlite3_user_data(context);
         928                 :            :     assert(ctx != NULL);
         929                 :          0 :     function_result = PyObject_CallMethodNoArgs(*aggregate_instance,
         930                 :          0 :                                                 ctx->state->str_finalize);
         931                 :          0 :     Py_DECREF(*aggregate_instance);
         932                 :            :
         933                 :          0 :     ok = 0;
         934         [ #  # ]:          0 :     if (function_result) {
         935                 :          0 :         ok = _pysqlite_set_result(context, function_result) == 0;
         936                 :          0 :         Py_DECREF(function_result);
         937                 :            :     }
         938         [ #  # ]:          0 :     if (!ok) {
         939                 :          0 :         int attr_err = PyErr_ExceptionMatches(PyExc_AttributeError);
         940                 :          0 :         _PyErr_ChainExceptions1(exc);
         941                 :            :
         942                 :            :         /* Note: contrary to the step, value, and inverse callbacks, SQLite
         943                 :            :          * does _not_, as of SQLite 3.38.0, propagate errors to sqlite3_step()
         944                 :            :          * from the finalize callback. This implies that execute*() will not
         945                 :            :          * raise OperationalError, as it normally would. */
         946         [ #  # ]:          0 :         set_sqlite_error(context, attr_err
         947                 :            :                 ? "user-defined aggregate's 'finalize' method not defined"
         948                 :            :                 : "user-defined aggregate's 'finalize' method raised error");
         949                 :            :     }
         950                 :            :     else {
         951                 :          0 :         PyErr_SetRaisedException(exc);
         952                 :            :     }
         953                 :            :
         954                 :          0 : error:
         955                 :          0 :     PyGILState_Release(threadstate);
         956                 :          0 : }
         957                 :            :
         958                 :          0 : static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self)
         959                 :            : {
         960                 :            :     PyObject* new_list;
         961                 :            :     PyObject* weakref;
         962                 :            :     int i;
         963                 :            :
         964                 :            :     /* we only need to do this once in a while */
         965         [ #  # ]:          0 :     if (self->created_cursors++ < 200) {
         966                 :          0 :         return;
         967                 :            :     }
         968                 :            :
         969                 :          0 :     self->created_cursors = 0;
         970                 :            :
         971                 :          0 :     new_list = PyList_New(0);
         972         [ #  # ]:          0 :     if (!new_list) {
         973                 :          0 :         return;
         974                 :            :     }
         975                 :            :
         976         [ #  # ]:          0 :     for (i = 0; i < PyList_Size(self->cursors); i++) {
         977                 :          0 :         weakref = PyList_GetItem(self->cursors, i);
         978         [ #  # ]:          0 :         if (PyWeakref_GetObject(weakref) != Py_None) {
         979         [ #  # ]:          0 :             if (PyList_Append(new_list, weakref) != 0) {
         980                 :          0 :                 Py_DECREF(new_list);
         981                 :          0 :                 return;
         982                 :            :             }
         983                 :            :         }
         984                 :            :     }
         985                 :            :
         986                 :          0 :     Py_SETREF(self->cursors, new_list);
         987                 :            : }
         988                 :            :
         989                 :            : /* Allocate a UDF/callback context structure. In order to ensure that the state
         990                 :            :  * pointer always outlives the callback context, we make sure it owns a
         991                 :            :  * reference to the module itself. create_callback_context() is always called
         992                 :            :  * from connection methods, so we use the defining class to fetch the module
         993                 :            :  * pointer.
         994                 :            :  */
         995                 :            : static callback_context *
         996                 :          0 : create_callback_context(PyTypeObject *cls, PyObject *callable)
         997                 :            : {
         998                 :          0 :     callback_context *ctx = PyMem_Malloc(sizeof(callback_context));
         999         [ #  # ]:          0 :     if (ctx != NULL) {
        1000                 :          0 :         PyObject *module = PyType_GetModule(cls);
        1001                 :          0 :         ctx->callable = Py_NewRef(callable);
        1002                 :          0 :         ctx->module = Py_NewRef(module);
        1003                 :          0 :         ctx->state = pysqlite_get_state(module);
        1004                 :            :     }
        1005                 :          0 :     return ctx;
        1006                 :            : }
        1007                 :            :
        1008                 :            : static void
        1009                 :          0 : free_callback_context(callback_context *ctx)
        1010                 :            : {
        1011                 :            :     assert(ctx != NULL);
        1012                 :          0 :     Py_XDECREF(ctx->callable);
        1013                 :          0 :     Py_XDECREF(ctx->module);
        1014                 :          0 :     PyMem_Free(ctx);
        1015                 :          0 : }
        1016                 :            :
        1017                 :            : static void
        1018                 :          0 : set_callback_context(callback_context **ctx_pp, callback_context *ctx)
        1019                 :            : {
        1020                 :            :     assert(ctx_pp != NULL);
        1021                 :          0 :     callback_context *tmp = *ctx_pp;
        1022                 :          0 :     *ctx_pp = ctx;
        1023         [ #  # ]:          0 :     if (tmp != NULL) {
        1024                 :          0 :         free_callback_context(tmp);
        1025                 :            :     }
        1026                 :          0 : }
        1027                 :            :
        1028                 :            : static void
        1029                 :          0 : destructor_callback(void *ctx)
        1030                 :            : {
        1031         [ #  # ]:          0 :     if (ctx != NULL) {
        1032                 :            :         // This function may be called without the GIL held, so we need to
        1033                 :            :         // ensure that we destroy 'ctx' with the GIL held.
        1034                 :          0 :         PyGILState_STATE gstate = PyGILState_Ensure();
        1035                 :          0 :         free_callback_context((callback_context *)ctx);
        1036                 :          0 :         PyGILState_Release(gstate);
        1037                 :            :     }
        1038                 :          0 : }
        1039                 :            :
        1040                 :            : /*[clinic input]
        1041                 :            : _sqlite3.Connection.create_function as pysqlite_connection_create_function
        1042                 :            :
        1043                 :            :     cls: defining_class
        1044                 :            :     /
        1045                 :            :     name: str
        1046                 :            :     narg: int
        1047                 :            :     func: object
        1048                 :            :     *
        1049                 :            :     deterministic: bool = False
        1050                 :            :
        1051                 :            : Creates a new function.
        1052                 :            : [clinic start generated code]*/
        1053                 :            :
        1054                 :            : static PyObject *
        1055                 :          0 : pysqlite_connection_create_function_impl(pysqlite_Connection *self,
        1056                 :            :                                          PyTypeObject *cls, const char *name,
        1057                 :            :                                          int narg, PyObject *func,
        1058                 :            :                                          int deterministic)
        1059                 :            : /*[clinic end generated code: output=8a811529287ad240 input=b3e8e1d8ddaffbef]*/
        1060                 :            : {
        1061                 :            :     int rc;
        1062                 :          0 :     int flags = SQLITE_UTF8;
        1063                 :            :
        1064   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1065                 :          0 :         return NULL;
        1066                 :            :     }
        1067                 :            :
        1068         [ #  # ]:          0 :     if (deterministic) {
        1069                 :            : #if SQLITE_VERSION_NUMBER < 3008003
        1070                 :            :         PyErr_SetString(self->NotSupportedError,
        1071                 :            :                         "deterministic=True requires SQLite 3.8.3 or higher");
        1072                 :            :         return NULL;
        1073                 :            : #else
        1074         [ #  # ]:          0 :         if (sqlite3_libversion_number() < 3008003) {
        1075                 :          0 :             PyErr_SetString(self->NotSupportedError,
        1076                 :            :                             "deterministic=True requires SQLite 3.8.3 or higher");
        1077                 :          0 :             return NULL;
        1078                 :            :         }
        1079                 :          0 :         flags |= SQLITE_DETERMINISTIC;
        1080                 :            : #endif
        1081                 :            :     }
        1082                 :          0 :     callback_context *ctx = create_callback_context(cls, func);
        1083         [ #  # ]:          0 :     if (ctx == NULL) {
        1084                 :          0 :         return NULL;
        1085                 :            :     }
        1086                 :          0 :     rc = sqlite3_create_function_v2(self->db, name, narg, flags, ctx,
        1087                 :            :                                     func_callback,
        1088                 :            :                                     NULL,
        1089                 :            :                                     NULL,
        1090                 :            :                                     &destructor_callback);  // will decref func
        1091                 :            :
        1092         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
        1093                 :            :         /* Workaround for SQLite bug: no error code or string is available here */
        1094                 :          0 :         PyErr_SetString(self->OperationalError, "Error creating function");
        1095                 :          0 :         return NULL;
        1096                 :            :     }
        1097                 :          0 :     Py_RETURN_NONE;
        1098                 :            : }
        1099                 :            :
        1100                 :            : #ifdef HAVE_WINDOW_FUNCTIONS
        1101                 :            : /*
        1102                 :            :  * Regarding the 'inverse' aggregate callback:
        1103                 :            :  * This method is only required by window aggregate functions, not
        1104                 :            :  * ordinary aggregate function implementations.  It is invoked to remove
        1105                 :            :  * a row from the current window.  The function arguments, if any,
        1106                 :            :  * correspond to the row being removed.
        1107                 :            :  */
        1108                 :            : static void
        1109                 :          0 : inverse_callback(sqlite3_context *context, int argc, sqlite3_value **params)
        1110                 :            : {
        1111                 :          0 :     PyGILState_STATE gilstate = PyGILState_Ensure();
        1112                 :            :
        1113                 :          0 :     callback_context *ctx = (callback_context *)sqlite3_user_data(context);
        1114                 :            :     assert(ctx != NULL);
        1115                 :            :
        1116                 :          0 :     int size = sizeof(PyObject *);
        1117                 :          0 :     PyObject **cls = (PyObject **)sqlite3_aggregate_context(context, size);
        1118                 :            :     assert(cls != NULL);
        1119                 :            :     assert(*cls != NULL);
        1120                 :            :
        1121                 :          0 :     PyObject *method = PyObject_GetAttr(*cls, ctx->state->str_inverse);
        1122         [ #  # ]:          0 :     if (method == NULL) {
        1123                 :          0 :         set_sqlite_error(context,
        1124                 :            :                 "user-defined aggregate's 'inverse' method not defined");
        1125                 :          0 :         goto exit;
        1126                 :            :     }
        1127                 :            :
        1128                 :          0 :     PyObject *args = _pysqlite_build_py_params(context, argc, params);
        1129         [ #  # ]:          0 :     if (args == NULL) {
        1130                 :          0 :         set_sqlite_error(context,
        1131                 :            :                 "unable to build arguments for user-defined aggregate's "
        1132                 :            :                 "'inverse' method");
        1133                 :          0 :         goto exit;
        1134                 :            :     }
        1135                 :            :
        1136                 :          0 :     PyObject *res = PyObject_CallObject(method, args);
        1137                 :          0 :     Py_DECREF(args);
        1138         [ #  # ]:          0 :     if (res == NULL) {
        1139                 :          0 :         set_sqlite_error(context,
        1140                 :            :                 "user-defined aggregate's 'inverse' method raised error");
        1141                 :          0 :         goto exit;
        1142                 :            :     }
        1143                 :          0 :     Py_DECREF(res);
        1144                 :            :
        1145                 :          0 : exit:
        1146                 :          0 :     Py_XDECREF(method);
        1147                 :          0 :     PyGILState_Release(gilstate);
        1148                 :          0 : }
        1149                 :            :
        1150                 :            : /*
        1151                 :            :  * Regarding the 'value' aggregate callback:
        1152                 :            :  * This method is only required by window aggregate functions, not
        1153                 :            :  * ordinary aggregate function implementations.  It is invoked to return
        1154                 :            :  * the current value of the aggregate.
        1155                 :            :  */
        1156                 :            : static void
        1157                 :          0 : value_callback(sqlite3_context *context)
        1158                 :            : {
        1159                 :          0 :     PyGILState_STATE gilstate = PyGILState_Ensure();
        1160                 :            :
        1161                 :          0 :     callback_context *ctx = (callback_context *)sqlite3_user_data(context);
        1162                 :            :     assert(ctx != NULL);
        1163                 :            :
        1164                 :          0 :     int size = sizeof(PyObject *);
        1165                 :          0 :     PyObject **cls = (PyObject **)sqlite3_aggregate_context(context, size);
        1166                 :            :     assert(cls != NULL);
        1167                 :            :     assert(*cls != NULL);
        1168                 :            :
        1169                 :          0 :     PyObject *res = PyObject_CallMethodNoArgs(*cls, ctx->state->str_value);
        1170         [ #  # ]:          0 :     if (res == NULL) {
        1171                 :          0 :         int attr_err = PyErr_ExceptionMatches(PyExc_AttributeError);
        1172         [ #  # ]:          0 :         set_sqlite_error(context, attr_err
        1173                 :            :                 ? "user-defined aggregate's 'value' method not defined"
        1174                 :            :                 : "user-defined aggregate's 'value' method raised error");
        1175                 :            :     }
        1176                 :            :     else {
        1177                 :          0 :         int rc = _pysqlite_set_result(context, res);
        1178                 :          0 :         Py_DECREF(res);
        1179         [ #  # ]:          0 :         if (rc < 0) {
        1180                 :          0 :             set_sqlite_error(context,
        1181                 :            :                     "unable to set result from user-defined aggregate's "
        1182                 :            :                     "'value' method");
        1183                 :            :         }
        1184                 :            :     }
        1185                 :            :
        1186                 :          0 :     PyGILState_Release(gilstate);
        1187                 :          0 : }
        1188                 :            :
        1189                 :            : /*[clinic input]
        1190                 :            : _sqlite3.Connection.create_window_function as create_window_function
        1191                 :            :
        1192                 :            :     cls: defining_class
        1193                 :            :     name: str
        1194                 :            :         The name of the SQL aggregate window function to be created or
        1195                 :            :         redefined.
        1196                 :            :     num_params: int
        1197                 :            :         The number of arguments the step and inverse methods takes.
        1198                 :            :     aggregate_class: object
        1199                 :            :         A class with step(), finalize(), value(), and inverse() methods.
        1200                 :            :         Set to None to clear the window function.
        1201                 :            :     /
        1202                 :            :
        1203                 :            : Creates or redefines an aggregate window function. Non-standard.
        1204                 :            : [clinic start generated code]*/
        1205                 :            :
        1206                 :            : static PyObject *
        1207                 :          0 : create_window_function_impl(pysqlite_Connection *self, PyTypeObject *cls,
        1208                 :            :                             const char *name, int num_params,
        1209                 :            :                             PyObject *aggregate_class)
        1210                 :            : /*[clinic end generated code: output=5332cd9464522235 input=46d57a54225b5228]*/
        1211                 :            : {
        1212         [ #  # ]:          0 :     if (sqlite3_libversion_number() < 3025000) {
        1213                 :          0 :         PyErr_SetString(self->NotSupportedError,
        1214                 :            :                         "create_window_function() requires "
        1215                 :            :                         "SQLite 3.25.0 or higher");
        1216                 :          0 :         return NULL;
        1217                 :            :     }
        1218                 :            :
        1219   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1220                 :          0 :         return NULL;
        1221                 :            :     }
        1222                 :            :
        1223                 :          0 :     int flags = SQLITE_UTF8;
        1224                 :            :     int rc;
        1225         [ #  # ]:          0 :     if (Py_IsNone(aggregate_class)) {
        1226                 :          0 :         rc = sqlite3_create_window_function(self->db, name, num_params, flags,
        1227                 :            :                                             0, 0, 0, 0, 0, 0);
        1228                 :            :     }
        1229                 :            :     else {
        1230                 :          0 :         callback_context *ctx = create_callback_context(cls, aggregate_class);
        1231         [ #  # ]:          0 :         if (ctx == NULL) {
        1232                 :          0 :             return NULL;
        1233                 :            :         }
        1234                 :          0 :         rc = sqlite3_create_window_function(self->db, name, num_params, flags,
        1235                 :            :                                             ctx,
        1236                 :            :                                             &step_callback,
        1237                 :            :                                             &final_callback,
        1238                 :            :                                             &value_callback,
        1239                 :            :                                             &inverse_callback,
        1240                 :            :                                             &destructor_callback);
        1241                 :            :     }
        1242                 :            :
        1243         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
        1244                 :            :         // Errors are not set on the database connection, so we cannot
        1245                 :            :         // use _pysqlite_seterror().
        1246                 :          0 :         PyErr_SetString(self->ProgrammingError, sqlite3_errstr(rc));
        1247                 :          0 :         return NULL;
        1248                 :            :     }
        1249                 :          0 :     Py_RETURN_NONE;
        1250                 :            : }
        1251                 :            : #endif
        1252                 :            :
        1253                 :            : /*[clinic input]
        1254                 :            : _sqlite3.Connection.create_aggregate as pysqlite_connection_create_aggregate
        1255                 :            :
        1256                 :            :     cls: defining_class
        1257                 :            :     /
        1258                 :            :     name: str
        1259                 :            :     n_arg: int
        1260                 :            :     aggregate_class: object
        1261                 :            :
        1262                 :            : Creates a new aggregate.
        1263                 :            : [clinic start generated code]*/
        1264                 :            :
        1265                 :            : static PyObject *
        1266                 :          0 : pysqlite_connection_create_aggregate_impl(pysqlite_Connection *self,
        1267                 :            :                                           PyTypeObject *cls,
        1268                 :            :                                           const char *name, int n_arg,
        1269                 :            :                                           PyObject *aggregate_class)
        1270                 :            : /*[clinic end generated code: output=1b02d0f0aec7ff96 input=68a2a26366d4c686]*/
        1271                 :            : {
        1272                 :            :     int rc;
        1273                 :            :
        1274   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1275                 :          0 :         return NULL;
        1276                 :            :     }
        1277                 :            :
        1278                 :          0 :     callback_context *ctx = create_callback_context(cls, aggregate_class);
        1279         [ #  # ]:          0 :     if (ctx == NULL) {
        1280                 :          0 :         return NULL;
        1281                 :            :     }
        1282                 :          0 :     rc = sqlite3_create_function_v2(self->db, name, n_arg, SQLITE_UTF8, ctx,
        1283                 :            :                                     0,
        1284                 :            :                                     &step_callback,
        1285                 :            :                                     &final_callback,
        1286                 :            :                                     &destructor_callback); // will decref func
        1287         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
        1288                 :            :         /* Workaround for SQLite bug: no error code or string is available here */
        1289                 :          0 :         PyErr_SetString(self->OperationalError, "Error creating aggregate");
        1290                 :          0 :         return NULL;
        1291                 :            :     }
        1292                 :          0 :     Py_RETURN_NONE;
        1293                 :            : }
        1294                 :            :
        1295                 :            : static int
        1296                 :          0 : authorizer_callback(void *ctx, int action, const char *arg1,
        1297                 :            :                     const char *arg2 , const char *dbname,
        1298                 :            :                     const char *access_attempt_source)
        1299                 :            : {
        1300                 :          0 :     PyGILState_STATE gilstate = PyGILState_Ensure();
        1301                 :            :
        1302                 :            :     PyObject *ret;
        1303                 :          0 :     int rc = SQLITE_DENY;
        1304                 :            :
        1305                 :            :     assert(ctx != NULL);
        1306                 :          0 :     PyObject *callable = ((callback_context *)ctx)->callable;
        1307                 :          0 :     ret = PyObject_CallFunction(callable, "issss", action, arg1, arg2, dbname,
        1308                 :            :                                 access_attempt_source);
        1309                 :            :
        1310         [ #  # ]:          0 :     if (ret == NULL) {
        1311                 :          0 :         print_or_clear_traceback(ctx);
        1312                 :          0 :         rc = SQLITE_DENY;
        1313                 :            :     }
        1314                 :            :     else {
        1315         [ #  # ]:          0 :         if (PyLong_Check(ret)) {
        1316                 :          0 :             rc = _PyLong_AsInt(ret);
        1317   [ #  #  #  # ]:          0 :             if (rc == -1 && PyErr_Occurred()) {
        1318                 :          0 :                 print_or_clear_traceback(ctx);
        1319                 :          0 :                 rc = SQLITE_DENY;
        1320                 :            :             }
        1321                 :            :         }
        1322                 :            :         else {
        1323                 :          0 :             rc = SQLITE_DENY;
        1324                 :            :         }
        1325                 :          0 :         Py_DECREF(ret);
        1326                 :            :     }
        1327                 :            :
        1328                 :          0 :     PyGILState_Release(gilstate);
        1329                 :          0 :     return rc;
        1330                 :            : }
        1331                 :            :
        1332                 :            : static int
        1333                 :          0 : progress_callback(void *ctx)
        1334                 :            : {
        1335                 :          0 :     PyGILState_STATE gilstate = PyGILState_Ensure();
        1336                 :            :
        1337                 :            :     int rc;
        1338                 :            :     PyObject *ret;
        1339                 :            :
        1340                 :            :     assert(ctx != NULL);
        1341                 :          0 :     PyObject *callable = ((callback_context *)ctx)->callable;
        1342                 :          0 :     ret = PyObject_CallNoArgs(callable);
        1343         [ #  # ]:          0 :     if (!ret) {
        1344                 :            :         /* abort query if error occurred */
        1345                 :          0 :         rc = -1;
        1346                 :            :     }
        1347                 :            :     else {
        1348                 :          0 :         rc = PyObject_IsTrue(ret);
        1349                 :          0 :         Py_DECREF(ret);
        1350                 :            :     }
        1351         [ #  # ]:          0 :     if (rc < 0) {
        1352                 :          0 :         print_or_clear_traceback(ctx);
        1353                 :            :     }
        1354                 :            :
        1355                 :          0 :     PyGILState_Release(gilstate);
        1356                 :          0 :     return rc;
        1357                 :            : }
        1358                 :            :
        1359                 :            : #ifdef HAVE_TRACE_V2
        1360                 :            : /*
        1361                 :            :  * From https://sqlite.org/c3ref/trace_v2.html:
        1362                 :            :  * The integer return value from the callback is currently ignored, though this
        1363                 :            :  * may change in future releases. Callback implementations should return zero
        1364                 :            :  * to ensure future compatibility.
        1365                 :            :  */
        1366                 :            : static int
        1367                 :          0 : trace_callback(unsigned int type, void *ctx, void *stmt, void *sql)
        1368                 :            : #else
        1369                 :            : static void
        1370                 :            : trace_callback(void *ctx, const char *sql)
        1371                 :            : #endif
        1372                 :            : {
        1373                 :            : #ifdef HAVE_TRACE_V2
        1374         [ #  # ]:          0 :     if (type != SQLITE_TRACE_STMT) {
        1375                 :          0 :         return 0;
        1376                 :            :     }
        1377                 :            : #endif
        1378                 :            :
        1379                 :          0 :     PyGILState_STATE gilstate = PyGILState_Ensure();
        1380                 :            :
        1381                 :            :     assert(ctx != NULL);
        1382                 :          0 :     pysqlite_state *state = ((callback_context *)ctx)->state;
        1383                 :            :     assert(state != NULL);
        1384                 :            :
        1385                 :          0 :     PyObject *py_statement = NULL;
        1386                 :            : #ifdef HAVE_TRACE_V2
        1387                 :          0 :     const char *expanded_sql = sqlite3_expanded_sql((sqlite3_stmt *)stmt);
        1388         [ #  # ]:          0 :     if (expanded_sql == NULL) {
        1389                 :          0 :         sqlite3 *db = sqlite3_db_handle((sqlite3_stmt *)stmt);
        1390         [ #  # ]:          0 :         if (sqlite3_errcode(db) == SQLITE_NOMEM) {
        1391                 :          0 :             (void)PyErr_NoMemory();
        1392                 :          0 :             goto exit;
        1393                 :            :         }
        1394                 :            :
        1395                 :          0 :         PyErr_SetString(state->DataError,
        1396                 :            :                 "Expanded SQL string exceeds the maximum string length");
        1397                 :          0 :         print_or_clear_traceback((callback_context *)ctx);
        1398                 :            :
        1399                 :            :         // Fall back to unexpanded sql
        1400                 :          0 :         py_statement = PyUnicode_FromString((const char *)sql);
        1401                 :            :     }
        1402                 :            :     else {
        1403                 :          0 :         py_statement = PyUnicode_FromString(expanded_sql);
        1404                 :          0 :         sqlite3_free((void *)expanded_sql);
        1405                 :            :     }
        1406                 :            : #else
        1407                 :            :     if (sql == NULL) {
        1408                 :            :         PyErr_SetString(state->DataError,
        1409                 :            :                 "Expanded SQL string exceeds the maximum string length");
        1410                 :            :         print_or_clear_traceback((callback_context *)ctx);
        1411                 :            :         goto exit;
        1412                 :            :     }
        1413                 :            :     py_statement = PyUnicode_FromString(sql);
        1414                 :            : #endif
        1415         [ #  # ]:          0 :     if (py_statement) {
        1416                 :          0 :         PyObject *callable = ((callback_context *)ctx)->callable;
        1417                 :          0 :         PyObject *ret = PyObject_CallOneArg(callable, py_statement);
        1418                 :          0 :         Py_DECREF(py_statement);
        1419                 :          0 :         Py_XDECREF(ret);
        1420                 :            :     }
        1421         [ #  # ]:          0 :     if (PyErr_Occurred()) {
        1422                 :          0 :         print_or_clear_traceback((callback_context *)ctx);
        1423                 :            :     }
        1424                 :            :
        1425                 :          0 : exit:
        1426                 :          0 :     PyGILState_Release(gilstate);
        1427                 :            : #ifdef HAVE_TRACE_V2
        1428                 :          0 :     return 0;
        1429                 :            : #endif
        1430                 :            : }
        1431                 :            :
        1432                 :            : /*[clinic input]
        1433                 :            : _sqlite3.Connection.set_authorizer as pysqlite_connection_set_authorizer
        1434                 :            :
        1435                 :            :     cls: defining_class
        1436                 :            :     /
        1437                 :            :     authorizer_callback as callable: object
        1438                 :            :
        1439                 :            : Sets authorizer callback.
        1440                 :            : [clinic start generated code]*/
        1441                 :            :
        1442                 :            : static PyObject *
        1443                 :          0 : pysqlite_connection_set_authorizer_impl(pysqlite_Connection *self,
        1444                 :            :                                         PyTypeObject *cls,
        1445                 :            :                                         PyObject *callable)
        1446                 :            : /*[clinic end generated code: output=75fa60114fc971c3 input=605d32ba92dd3eca]*/
        1447                 :            : {
        1448   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1449                 :          0 :         return NULL;
        1450                 :            :     }
        1451                 :            :
        1452                 :            :     int rc;
        1453         [ #  # ]:          0 :     if (callable == Py_None) {
        1454                 :          0 :         rc = sqlite3_set_authorizer(self->db, NULL, NULL);
        1455                 :          0 :         set_callback_context(&self->authorizer_ctx, NULL);
        1456                 :            :     }
        1457                 :            :     else {
        1458                 :          0 :         callback_context *ctx = create_callback_context(cls, callable);
        1459         [ #  # ]:          0 :         if (ctx == NULL) {
        1460                 :          0 :             return NULL;
        1461                 :            :         }
        1462                 :          0 :         rc = sqlite3_set_authorizer(self->db, authorizer_callback, ctx);
        1463                 :          0 :         set_callback_context(&self->authorizer_ctx, ctx);
        1464                 :            :     }
        1465         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
        1466                 :          0 :         PyErr_SetString(self->OperationalError,
        1467                 :            :                         "Error setting authorizer callback");
        1468                 :          0 :         set_callback_context(&self->authorizer_ctx, NULL);
        1469                 :          0 :         return NULL;
        1470                 :            :     }
        1471                 :          0 :     Py_RETURN_NONE;
        1472                 :            : }
        1473                 :            :
        1474                 :            : /*[clinic input]
        1475                 :            : _sqlite3.Connection.set_progress_handler as pysqlite_connection_set_progress_handler
        1476                 :            :
        1477                 :            :     cls: defining_class
        1478                 :            :     /
        1479                 :            :     progress_handler as callable: object
        1480                 :            :     n: int
        1481                 :            :
        1482                 :            : Sets progress handler callback.
        1483                 :            : [clinic start generated code]*/
        1484                 :            :
        1485                 :            : static PyObject *
        1486                 :          0 : pysqlite_connection_set_progress_handler_impl(pysqlite_Connection *self,
        1487                 :            :                                               PyTypeObject *cls,
        1488                 :            :                                               PyObject *callable, int n)
        1489                 :            : /*[clinic end generated code: output=0739957fd8034a50 input=f7c1837984bd86db]*/
        1490                 :            : {
        1491   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1492                 :          0 :         return NULL;
        1493                 :            :     }
        1494                 :            :
        1495         [ #  # ]:          0 :     if (callable == Py_None) {
        1496                 :            :         /* None clears the progress handler previously set */
        1497                 :          0 :         sqlite3_progress_handler(self->db, 0, 0, (void*)0);
        1498                 :          0 :         set_callback_context(&self->progress_ctx, NULL);
        1499                 :            :     }
        1500                 :            :     else {
        1501                 :          0 :         callback_context *ctx = create_callback_context(cls, callable);
        1502         [ #  # ]:          0 :         if (ctx == NULL) {
        1503                 :          0 :             return NULL;
        1504                 :            :         }
        1505                 :          0 :         sqlite3_progress_handler(self->db, n, progress_callback, ctx);
        1506                 :          0 :         set_callback_context(&self->progress_ctx, ctx);
        1507                 :            :     }
        1508                 :          0 :     Py_RETURN_NONE;
        1509                 :            : }
        1510                 :            :
        1511                 :            : /*[clinic input]
        1512                 :            : _sqlite3.Connection.set_trace_callback as pysqlite_connection_set_trace_callback
        1513                 :            :
        1514                 :            :     cls: defining_class
        1515                 :            :     /
        1516                 :            :     trace_callback as callable: object
        1517                 :            :
        1518                 :            : Sets a trace callback called for each SQL statement (passed as unicode).
        1519                 :            : [clinic start generated code]*/
        1520                 :            :
        1521                 :            : static PyObject *
        1522                 :          0 : pysqlite_connection_set_trace_callback_impl(pysqlite_Connection *self,
        1523                 :            :                                             PyTypeObject *cls,
        1524                 :            :                                             PyObject *callable)
        1525                 :            : /*[clinic end generated code: output=d91048c03bfcee05 input=351a94210c5f81bb]*/
        1526                 :            : {
        1527   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1528                 :          0 :         return NULL;
        1529                 :            :     }
        1530                 :            :
        1531         [ #  # ]:          0 :     if (callable == Py_None) {
        1532                 :            :         /*
        1533                 :            :          * None clears the trace callback previously set
        1534                 :            :          *
        1535                 :            :          * Ref.
        1536                 :            :          * - https://sqlite.org/c3ref/c_trace.html
        1537                 :            :          * - https://sqlite.org/c3ref/trace_v2.html
        1538                 :            :          */
        1539                 :            : #ifdef HAVE_TRACE_V2
        1540                 :          0 :         sqlite3_trace_v2(self->db, SQLITE_TRACE_STMT, 0, 0);
        1541                 :            : #else
        1542                 :            :         sqlite3_trace(self->db, 0, (void*)0);
        1543                 :            : #endif
        1544                 :          0 :         set_callback_context(&self->trace_ctx, NULL);
        1545                 :            :     }
        1546                 :            :     else {
        1547                 :          0 :         callback_context *ctx = create_callback_context(cls, callable);
        1548         [ #  # ]:          0 :         if (ctx == NULL) {
        1549                 :          0 :             return NULL;
        1550                 :            :         }
        1551                 :            : #ifdef HAVE_TRACE_V2
        1552                 :          0 :         sqlite3_trace_v2(self->db, SQLITE_TRACE_STMT, trace_callback, ctx);
        1553                 :            : #else
        1554                 :            :         sqlite3_trace(self->db, trace_callback, ctx);
        1555                 :            : #endif
        1556                 :          0 :         set_callback_context(&self->trace_ctx, ctx);
        1557                 :            :     }
        1558                 :            :
        1559                 :          0 :     Py_RETURN_NONE;
        1560                 :            : }
        1561                 :            :
        1562                 :            : #ifdef PY_SQLITE_ENABLE_LOAD_EXTENSION
        1563                 :            : /*[clinic input]
        1564                 :            : _sqlite3.Connection.enable_load_extension as pysqlite_connection_enable_load_extension
        1565                 :            :
        1566                 :            :     enable as onoff: bool
        1567                 :            :     /
        1568                 :            :
        1569                 :            : Enable dynamic loading of SQLite extension modules.
        1570                 :            : [clinic start generated code]*/
        1571                 :            :
        1572                 :            : static PyObject *
        1573                 :            : pysqlite_connection_enable_load_extension_impl(pysqlite_Connection *self,
        1574                 :            :                                                int onoff)
        1575                 :            : /*[clinic end generated code: output=9cac37190d388baf input=2a1e87931486380f]*/
        1576                 :            : {
        1577                 :            :     int rc;
        1578                 :            :
        1579                 :            :     if (PySys_Audit("sqlite3.enable_load_extension",
        1580                 :            :                     "OO", self, onoff ? Py_True : Py_False) < 0) {
        1581                 :            :         return NULL;
        1582                 :            :     }
        1583                 :            :
        1584                 :            :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1585                 :            :         return NULL;
        1586                 :            :     }
        1587                 :            :
        1588                 :            :     rc = sqlite3_enable_load_extension(self->db, onoff);
        1589                 :            :
        1590                 :            :     if (rc != SQLITE_OK) {
        1591                 :            :         PyErr_SetString(self->OperationalError,
        1592                 :            :                         "Error enabling load extension");
        1593                 :            :         return NULL;
        1594                 :            :     } else {
        1595                 :            :         Py_RETURN_NONE;
        1596                 :            :     }
        1597                 :            : }
        1598                 :            :
        1599                 :            : /*[clinic input]
        1600                 :            : _sqlite3.Connection.load_extension as pysqlite_connection_load_extension
        1601                 :            :
        1602                 :            :     name as extension_name: str
        1603                 :            :     /
        1604                 :            :
        1605                 :            : Load SQLite extension module.
        1606                 :            : [clinic start generated code]*/
        1607                 :            :
        1608                 :            : static PyObject *
        1609                 :            : pysqlite_connection_load_extension_impl(pysqlite_Connection *self,
        1610                 :            :                                         const char *extension_name)
        1611                 :            : /*[clinic end generated code: output=47eb1d7312bc97a7 input=edd507389d89d621]*/
        1612                 :            : {
        1613                 :            :     int rc;
        1614                 :            :     char* errmsg;
        1615                 :            :
        1616                 :            :     if (PySys_Audit("sqlite3.load_extension", "Os", self, extension_name) < 0) {
        1617                 :            :         return NULL;
        1618                 :            :     }
        1619                 :            :
        1620                 :            :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1621                 :            :         return NULL;
        1622                 :            :     }
        1623                 :            :
        1624                 :            :     rc = sqlite3_load_extension(self->db, extension_name, 0, &errmsg);
        1625                 :            :     if (rc != 0) {
        1626                 :            :         PyErr_SetString(self->OperationalError, errmsg);
        1627                 :            :         return NULL;
        1628                 :            :     } else {
        1629                 :            :         Py_RETURN_NONE;
        1630                 :            :     }
        1631                 :            : }
        1632                 :            : #endif
        1633                 :            :
        1634                 :          0 : int pysqlite_check_thread(pysqlite_Connection* self)
        1635                 :            : {
        1636         [ #  # ]:          0 :     if (self->check_same_thread) {
        1637         [ #  # ]:          0 :         if (PyThread_get_thread_ident() != self->thread_ident) {
        1638                 :          0 :             PyErr_Format(self->ProgrammingError,
        1639                 :            :                         "SQLite objects created in a thread can only be used in that same thread. "
        1640                 :            :                         "The object was created in thread id %lu and this is thread id %lu.",
        1641                 :            :                         self->thread_ident, PyThread_get_thread_ident());
        1642                 :          0 :             return 0;
        1643                 :            :         }
        1644                 :            :
        1645                 :            :     }
        1646                 :          0 :     return 1;
        1647                 :            : }
        1648                 :            :
        1649                 :          0 : static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)
        1650                 :            : {
        1651         [ #  # ]:          0 :     if (!pysqlite_check_connection(self)) {
        1652                 :          0 :         return NULL;
        1653                 :            :     }
        1654         [ #  # ]:          0 :     if (self->isolation_level != NULL) {
        1655                 :          0 :         return PyUnicode_FromString(self->isolation_level);
        1656                 :            :     }
        1657                 :          0 :     Py_RETURN_NONE;
        1658                 :            : }
        1659                 :            :
        1660                 :          0 : static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)
        1661                 :            : {
        1662         [ #  # ]:          0 :     if (!pysqlite_check_connection(self)) {
        1663                 :          0 :         return NULL;
        1664                 :            :     }
        1665                 :          0 :     return PyLong_FromLong(sqlite3_total_changes(self->db));
        1666                 :            : }
        1667                 :            :
        1668                 :          0 : static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* self, void* unused)
        1669                 :            : {
        1670         [ #  # ]:          0 :     if (!pysqlite_check_connection(self)) {
        1671                 :          0 :         return NULL;
        1672                 :            :     }
        1673         [ #  # ]:          0 :     if (!sqlite3_get_autocommit(self->db)) {
        1674                 :          0 :         Py_RETURN_TRUE;
        1675                 :            :     }
        1676                 :          0 :     Py_RETURN_FALSE;
        1677                 :            : }
        1678                 :            :
        1679                 :            : static int
        1680                 :          0 : pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored))
        1681                 :            : {
        1682         [ #  # ]:          0 :     if (isolation_level == NULL) {
        1683                 :          0 :         PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
        1684                 :          0 :         return -1;
        1685                 :            :     }
        1686         [ #  # ]:          0 :     if (Py_IsNone(isolation_level)) {
        1687                 :          0 :         self->isolation_level = NULL;
        1688                 :            :
        1689                 :            :         // Execute a COMMIT to re-enable autocommit mode
        1690                 :          0 :         PyObject *res = pysqlite_connection_commit_impl(self);
        1691         [ #  # ]:          0 :         if (res == NULL) {
        1692                 :          0 :             return -1;
        1693                 :            :         }
        1694                 :          0 :         Py_DECREF(res);
        1695                 :          0 :         return 0;
        1696                 :            :     }
        1697         [ #  # ]:          0 :     if (!isolation_level_converter(isolation_level, &self->isolation_level)) {
        1698                 :          0 :         return -1;
        1699                 :            :     }
        1700                 :          0 :     return 0;
        1701                 :            : }
        1702                 :            :
        1703                 :            : static PyObject *
        1704                 :          0 : pysqlite_connection_call(pysqlite_Connection *self, PyObject *args,
        1705                 :            :                          PyObject *kwargs)
        1706                 :            : {
        1707                 :            :     PyObject* sql;
        1708                 :            :     pysqlite_Statement* statement;
        1709                 :            :
        1710   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1711                 :          0 :         return NULL;
        1712                 :            :     }
        1713                 :            :
        1714   [ #  #  #  # ]:          0 :     if (!_PyArg_NoKeywords(MODULE_NAME ".Connection", kwargs))
        1715                 :          0 :         return NULL;
        1716                 :            :
        1717         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "U", &sql))
        1718                 :          0 :         return NULL;
        1719                 :            :
        1720                 :          0 :     statement = pysqlite_statement_create(self, sql);
        1721         [ #  # ]:          0 :     if (statement == NULL) {
        1722                 :          0 :         return NULL;
        1723                 :            :     }
        1724                 :            :
        1725                 :          0 :     return (PyObject*)statement;
        1726                 :            : }
        1727                 :            :
        1728                 :            : /*[clinic input]
        1729                 :            : _sqlite3.Connection.execute as pysqlite_connection_execute
        1730                 :            :
        1731                 :            :     sql: unicode
        1732                 :            :     parameters: object = NULL
        1733                 :            :     /
        1734                 :            :
        1735                 :            : Executes an SQL statement.
        1736                 :            : [clinic start generated code]*/
        1737                 :            :
        1738                 :            : static PyObject *
        1739                 :          0 : pysqlite_connection_execute_impl(pysqlite_Connection *self, PyObject *sql,
        1740                 :            :                                  PyObject *parameters)
        1741                 :            : /*[clinic end generated code: output=5be05ae01ee17ee4 input=27aa7792681ddba2]*/
        1742                 :            : {
        1743                 :          0 :     PyObject* result = 0;
        1744                 :            :
        1745                 :          0 :     PyObject *cursor = pysqlite_connection_cursor_impl(self, NULL);
        1746         [ #  # ]:          0 :     if (!cursor) {
        1747                 :          0 :         goto error;
        1748                 :            :     }
        1749                 :            :
        1750                 :          0 :     result = _pysqlite_query_execute((pysqlite_Cursor *)cursor, 0, sql, parameters);
        1751         [ #  # ]:          0 :     if (!result) {
        1752         [ #  # ]:          0 :         Py_CLEAR(cursor);
        1753                 :            :     }
        1754                 :            :
        1755                 :          0 : error:
        1756                 :          0 :     Py_XDECREF(result);
        1757                 :            :
        1758                 :          0 :     return cursor;
        1759                 :            : }
        1760                 :            :
        1761                 :            : /*[clinic input]
        1762                 :            : _sqlite3.Connection.executemany as pysqlite_connection_executemany
        1763                 :            :
        1764                 :            :     sql: unicode
        1765                 :            :     parameters: object
        1766                 :            :     /
        1767                 :            :
        1768                 :            : Repeatedly executes an SQL statement.
        1769                 :            : [clinic start generated code]*/
        1770                 :            :
        1771                 :            : static PyObject *
        1772                 :          0 : pysqlite_connection_executemany_impl(pysqlite_Connection *self,
        1773                 :            :                                      PyObject *sql, PyObject *parameters)
        1774                 :            : /*[clinic end generated code: output=776cd2fd20bfe71f input=495be76551d525db]*/
        1775                 :            : {
        1776                 :          0 :     PyObject* result = 0;
        1777                 :            :
        1778                 :          0 :     PyObject *cursor = pysqlite_connection_cursor_impl(self, NULL);
        1779         [ #  # ]:          0 :     if (!cursor) {
        1780                 :          0 :         goto error;
        1781                 :            :     }
        1782                 :            :
        1783                 :          0 :     result = _pysqlite_query_execute((pysqlite_Cursor *)cursor, 1, sql, parameters);
        1784         [ #  # ]:          0 :     if (!result) {
        1785         [ #  # ]:          0 :         Py_CLEAR(cursor);
        1786                 :            :     }
        1787                 :            :
        1788                 :          0 : error:
        1789                 :          0 :     Py_XDECREF(result);
        1790                 :            :
        1791                 :          0 :     return cursor;
        1792                 :            : }
        1793                 :            :
        1794                 :            : /*[clinic input]
        1795                 :            : _sqlite3.Connection.executescript as pysqlite_connection_executescript
        1796                 :            :
        1797                 :            :     sql_script as script_obj: object
        1798                 :            :     /
        1799                 :            :
        1800                 :            : Executes multiple SQL statements at once.
        1801                 :            : [clinic start generated code]*/
        1802                 :            :
        1803                 :            : static PyObject *
        1804                 :          0 : pysqlite_connection_executescript(pysqlite_Connection *self,
        1805                 :            :                                   PyObject *script_obj)
        1806                 :            : /*[clinic end generated code: output=4c4f9d77aa0ae37d input=f6e5f1ccfa313db4]*/
        1807                 :            : {
        1808                 :          0 :     PyObject* result = 0;
        1809                 :            :
        1810                 :          0 :     PyObject *cursor = pysqlite_connection_cursor_impl(self, NULL);
        1811         [ #  # ]:          0 :     if (!cursor) {
        1812                 :          0 :         goto error;
        1813                 :            :     }
        1814                 :            :
        1815                 :          0 :     PyObject *meth = self->state->str_executescript;  // borrowed ref.
        1816                 :          0 :     result = PyObject_CallMethodObjArgs(cursor, meth, script_obj, NULL);
        1817         [ #  # ]:          0 :     if (!result) {
        1818         [ #  # ]:          0 :         Py_CLEAR(cursor);
        1819                 :            :     }
        1820                 :            :
        1821                 :          0 : error:
        1822                 :          0 :     Py_XDECREF(result);
        1823                 :            :
        1824                 :          0 :     return cursor;
        1825                 :            : }
        1826                 :            :
        1827                 :            : /* ------------------------- COLLATION CODE ------------------------ */
        1828                 :            :
        1829                 :            : static int
        1830                 :          0 : collation_callback(void *context, int text1_length, const void *text1_data,
        1831                 :            :                    int text2_length, const void *text2_data)
        1832                 :            : {
        1833                 :          0 :     PyGILState_STATE gilstate = PyGILState_Ensure();
        1834                 :            :
        1835                 :          0 :     PyObject* string1 = 0;
        1836                 :          0 :     PyObject* string2 = 0;
        1837                 :          0 :     PyObject* retval = NULL;
        1838                 :            :     long longval;
        1839                 :          0 :     int result = 0;
        1840                 :            :
        1841                 :            :     /* This callback may be executed multiple times per sqlite3_step(). Bail if
        1842                 :            :      * the previous call failed */
        1843         [ #  # ]:          0 :     if (PyErr_Occurred()) {
        1844                 :          0 :         goto finally;
        1845                 :            :     }
        1846                 :            :
        1847                 :          0 :     string1 = PyUnicode_FromStringAndSize((const char*)text1_data, text1_length);
        1848                 :          0 :     string2 = PyUnicode_FromStringAndSize((const char*)text2_data, text2_length);
        1849                 :            :
        1850   [ #  #  #  # ]:          0 :     if (!string1 || !string2) {
        1851                 :          0 :         goto finally; /* failed to allocate strings */
        1852                 :            :     }
        1853                 :            :
        1854                 :          0 :     callback_context *ctx = (callback_context *)context;
        1855                 :            :     assert(ctx != NULL);
        1856                 :          0 :     PyObject *args[] = { NULL, string1, string2 };  // Borrowed refs.
        1857                 :          0 :     size_t nargsf = 2 | PY_VECTORCALL_ARGUMENTS_OFFSET;
        1858                 :          0 :     retval = PyObject_Vectorcall(ctx->callable, args + 1, nargsf, NULL);
        1859         [ #  # ]:          0 :     if (retval == NULL) {
        1860                 :            :         /* execution failed */
        1861                 :          0 :         goto finally;
        1862                 :            :     }
        1863                 :            :
        1864                 :          0 :     longval = PyLong_AsLongAndOverflow(retval, &result);
        1865   [ #  #  #  # ]:          0 :     if (longval == -1 && PyErr_Occurred()) {
        1866                 :          0 :         PyErr_Clear();
        1867                 :          0 :         result = 0;
        1868                 :            :     }
        1869         [ #  # ]:          0 :     else if (!result) {
        1870         [ #  # ]:          0 :         if (longval > 0)
        1871                 :          0 :             result = 1;
        1872         [ #  # ]:          0 :         else if (longval < 0)
        1873                 :          0 :             result = -1;
        1874                 :            :     }
        1875                 :            :
        1876                 :          0 : finally:
        1877                 :          0 :     Py_XDECREF(string1);
        1878                 :          0 :     Py_XDECREF(string2);
        1879                 :          0 :     Py_XDECREF(retval);
        1880                 :          0 :     PyGILState_Release(gilstate);
        1881                 :          0 :     return result;
        1882                 :            : }
        1883                 :            :
        1884                 :            : /*[clinic input]
        1885                 :            : _sqlite3.Connection.interrupt as pysqlite_connection_interrupt
        1886                 :            :
        1887                 :            : Abort any pending database operation.
        1888                 :            : [clinic start generated code]*/
        1889                 :            :
        1890                 :            : static PyObject *
        1891                 :          0 : pysqlite_connection_interrupt_impl(pysqlite_Connection *self)
        1892                 :            : /*[clinic end generated code: output=f193204bc9e70b47 input=75ad03ade7012859]*/
        1893                 :            : {
        1894                 :          0 :     PyObject* retval = NULL;
        1895                 :            :
        1896         [ #  # ]:          0 :     if (!pysqlite_check_connection(self)) {
        1897                 :          0 :         goto finally;
        1898                 :            :     }
        1899                 :            :
        1900                 :          0 :     sqlite3_interrupt(self->db);
        1901                 :            :
        1902                 :          0 :     retval = Py_NewRef(Py_None);
        1903                 :            :
        1904                 :          0 : finally:
        1905                 :          0 :     return retval;
        1906                 :            : }
        1907                 :            :
        1908                 :            : /* Function author: Paul Kippes <kippesp@gmail.com>
        1909                 :            :  * Class method of Connection to call the Python function _iterdump
        1910                 :            :  * of the sqlite3 module.
        1911                 :            :  */
        1912                 :            : /*[clinic input]
        1913                 :            : _sqlite3.Connection.iterdump as pysqlite_connection_iterdump
        1914                 :            :
        1915                 :            : Returns iterator to the dump of the database in an SQL text format.
        1916                 :            : [clinic start generated code]*/
        1917                 :            :
        1918                 :            : static PyObject *
        1919                 :          0 : pysqlite_connection_iterdump_impl(pysqlite_Connection *self)
        1920                 :            : /*[clinic end generated code: output=586997aaf9808768 input=1911ca756066da89]*/
        1921                 :            : {
        1922         [ #  # ]:          0 :     if (!pysqlite_check_connection(self)) {
        1923                 :          0 :         return NULL;
        1924                 :            :     }
        1925                 :            :
        1926                 :          0 :     PyObject *iterdump = _PyImport_GetModuleAttrString(MODULE_NAME ".dump", "_iterdump");
        1927         [ #  # ]:          0 :     if (!iterdump) {
        1928         [ #  # ]:          0 :         if (!PyErr_Occurred()) {
        1929                 :          0 :             PyErr_SetString(self->OperationalError,
        1930                 :            :                             "Failed to obtain _iterdump() reference");
        1931                 :            :         }
        1932                 :          0 :         return NULL;
        1933                 :            :     }
        1934                 :            :
        1935                 :          0 :     PyObject *retval = PyObject_CallOneArg(iterdump, (PyObject *)self);
        1936                 :          0 :     Py_DECREF(iterdump);
        1937                 :          0 :     return retval;
        1938                 :            : }
        1939                 :            :
        1940                 :            : /*[clinic input]
        1941                 :            : _sqlite3.Connection.backup as pysqlite_connection_backup
        1942                 :            :
        1943                 :            :     target: object(type='pysqlite_Connection *', subclass_of='clinic_state()->ConnectionType')
        1944                 :            :     *
        1945                 :            :     pages: int = -1
        1946                 :            :     progress: object = None
        1947                 :            :     name: str = "main"
        1948                 :            :     sleep: double = 0.250
        1949                 :            :
        1950                 :            : Makes a backup of the database.
        1951                 :            : [clinic start generated code]*/
        1952                 :            :
        1953                 :            : static PyObject *
        1954                 :          0 : pysqlite_connection_backup_impl(pysqlite_Connection *self,
        1955                 :            :                                 pysqlite_Connection *target, int pages,
        1956                 :            :                                 PyObject *progress, const char *name,
        1957                 :            :                                 double sleep)
        1958                 :            : /*[clinic end generated code: output=306a3e6a38c36334 input=c6519d0f59d0fd7f]*/
        1959                 :            : {
        1960                 :            :     int rc;
        1961                 :          0 :     int sleep_ms = (int)(sleep * 1000.0);
        1962                 :            :     sqlite3 *bck_conn;
        1963                 :            :     sqlite3_backup *bck_handle;
        1964                 :            :
        1965   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        1966                 :          0 :         return NULL;
        1967                 :            :     }
        1968                 :            :
        1969         [ #  # ]:          0 :     if (!pysqlite_check_connection(target)) {
        1970                 :          0 :         return NULL;
        1971                 :            :     }
        1972                 :            :
        1973         [ #  # ]:          0 :     if (target == self) {
        1974                 :          0 :         PyErr_SetString(PyExc_ValueError, "target cannot be the same connection instance");
        1975                 :          0 :         return NULL;
        1976                 :            :     }
        1977                 :            :
        1978                 :            : #if SQLITE_VERSION_NUMBER < 3008008
        1979                 :            :     /* Since 3.8.8 this is already done, per commit
        1980                 :            :        https://www.sqlite.org/src/info/169b5505498c0a7e */
        1981                 :            :     if (!sqlite3_get_autocommit(target->db)) {
        1982                 :            :         PyErr_SetString(self->OperationalError, "target is in transaction");
        1983                 :            :         return NULL;
        1984                 :            :     }
        1985                 :            : #endif
        1986                 :            :
        1987   [ #  #  #  # ]:          0 :     if (progress != Py_None && !PyCallable_Check(progress)) {
        1988                 :          0 :         PyErr_SetString(PyExc_TypeError, "progress argument must be a callable");
        1989                 :          0 :         return NULL;
        1990                 :            :     }
        1991                 :            :
        1992         [ #  # ]:          0 :     if (pages == 0) {
        1993                 :          0 :         pages = -1;
        1994                 :            :     }
        1995                 :            :
        1996                 :          0 :     bck_conn = target->db;
        1997                 :            :
        1998                 :          0 :     Py_BEGIN_ALLOW_THREADS
        1999                 :          0 :     bck_handle = sqlite3_backup_init(bck_conn, "main", self->db, name);
        2000                 :          0 :     Py_END_ALLOW_THREADS
        2001                 :            :
        2002         [ #  # ]:          0 :     if (bck_handle == NULL) {
        2003                 :          0 :         _pysqlite_seterror(self->state, bck_conn);
        2004                 :          0 :         return NULL;
        2005                 :            :     }
        2006                 :            :
        2007                 :            :     do {
        2008                 :          0 :         Py_BEGIN_ALLOW_THREADS
        2009                 :          0 :         rc = sqlite3_backup_step(bck_handle, pages);
        2010                 :          0 :         Py_END_ALLOW_THREADS
        2011                 :            :
        2012         [ #  # ]:          0 :         if (progress != Py_None) {
        2013                 :          0 :             int remaining = sqlite3_backup_remaining(bck_handle);
        2014                 :          0 :             int pagecount = sqlite3_backup_pagecount(bck_handle);
        2015                 :          0 :             PyObject *res = PyObject_CallFunction(progress, "iii", rc,
        2016                 :            :                                                   remaining, pagecount);
        2017         [ #  # ]:          0 :             if (res == NULL) {
        2018                 :            :                 /* Callback failed: abort backup and bail. */
        2019                 :          0 :                 Py_BEGIN_ALLOW_THREADS
        2020                 :          0 :                 sqlite3_backup_finish(bck_handle);
        2021                 :          0 :                 Py_END_ALLOW_THREADS
        2022                 :          0 :                 return NULL;
        2023                 :            :             }
        2024                 :          0 :             Py_DECREF(res);
        2025                 :            :         }
        2026                 :            :
        2027                 :            :         /* Sleep for a while if there are still further pages to copy and
        2028                 :            :            the engine could not make any progress */
        2029   [ #  #  #  # ]:          0 :         if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED) {
        2030                 :          0 :             Py_BEGIN_ALLOW_THREADS
        2031                 :          0 :             sqlite3_sleep(sleep_ms);
        2032                 :          0 :             Py_END_ALLOW_THREADS
        2033                 :            :         }
        2034   [ #  #  #  #  :          0 :     } while (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED);
                       #  # ]
        2035                 :            :
        2036                 :          0 :     Py_BEGIN_ALLOW_THREADS
        2037                 :          0 :     rc = sqlite3_backup_finish(bck_handle);
        2038                 :          0 :     Py_END_ALLOW_THREADS
        2039                 :            :
        2040         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
        2041                 :          0 :         _pysqlite_seterror(self->state, bck_conn);
        2042                 :          0 :         return NULL;
        2043                 :            :     }
        2044                 :            :
        2045                 :          0 :     Py_RETURN_NONE;
        2046                 :            : }
        2047                 :            :
        2048                 :            : /*[clinic input]
        2049                 :            : _sqlite3.Connection.create_collation as pysqlite_connection_create_collation
        2050                 :            :
        2051                 :            :     cls: defining_class
        2052                 :            :     name: str
        2053                 :            :     callback as callable: object
        2054                 :            :     /
        2055                 :            :
        2056                 :            : Creates a collation function.
        2057                 :            : [clinic start generated code]*/
        2058                 :            :
        2059                 :            : static PyObject *
        2060                 :          0 : pysqlite_connection_create_collation_impl(pysqlite_Connection *self,
        2061                 :            :                                           PyTypeObject *cls,
        2062                 :            :                                           const char *name,
        2063                 :            :                                           PyObject *callable)
        2064                 :            : /*[clinic end generated code: output=32d339e97869c378 input=f67ecd2e31e61ad3]*/
        2065                 :            : {
        2066   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        2067                 :          0 :         return NULL;
        2068                 :            :     }
        2069                 :            :
        2070                 :          0 :     callback_context *ctx = NULL;
        2071                 :            :     int rc;
        2072                 :          0 :     int flags = SQLITE_UTF8;
        2073         [ #  # ]:          0 :     if (callable == Py_None) {
        2074                 :          0 :         rc = sqlite3_create_collation_v2(self->db, name, flags,
        2075                 :            :                                          NULL, NULL, NULL);
        2076                 :            :     }
        2077                 :            :     else {
        2078         [ #  # ]:          0 :         if (!PyCallable_Check(callable)) {
        2079                 :          0 :             PyErr_SetString(PyExc_TypeError, "parameter must be callable");
        2080                 :          0 :             return NULL;
        2081                 :            :         }
        2082                 :          0 :         ctx = create_callback_context(cls, callable);
        2083         [ #  # ]:          0 :         if (ctx == NULL) {
        2084                 :          0 :             return NULL;
        2085                 :            :         }
        2086                 :          0 :         rc = sqlite3_create_collation_v2(self->db, name, flags, ctx,
        2087                 :            :                                          &collation_callback,
        2088                 :            :                                          &destructor_callback);
        2089                 :            :     }
        2090                 :            :
        2091         [ #  # ]:          0 :     if (rc != SQLITE_OK) {
        2092                 :            :         /* Unlike other sqlite3_* functions, the destructor callback is _not_
        2093                 :            :          * called if sqlite3_create_collation_v2() fails, so we have to free
        2094                 :            :          * the context before returning.
        2095                 :            :          */
        2096         [ #  # ]:          0 :         if (callable != Py_None) {
        2097                 :          0 :             free_callback_context(ctx);
        2098                 :            :         }
        2099                 :          0 :         _pysqlite_seterror(self->state, self->db);
        2100                 :          0 :         return NULL;
        2101                 :            :     }
        2102                 :            :
        2103                 :          0 :     Py_RETURN_NONE;
        2104                 :            : }
        2105                 :            :
        2106                 :            : #ifdef PY_SQLITE_HAVE_SERIALIZE
        2107                 :            : /*[clinic input]
        2108                 :            : _sqlite3.Connection.serialize as serialize
        2109                 :            :
        2110                 :            :     *
        2111                 :            :     name: str = "main"
        2112                 :            :         Which database to serialize.
        2113                 :            :
        2114                 :            : Serialize a database into a byte string.
        2115                 :            :
        2116                 :            : For an ordinary on-disk database file, the serialization is just a copy of the
        2117                 :            : disk file. For an in-memory database or a "temp" database, the serialization is
        2118                 :            : the same sequence of bytes which would be written to disk if that database
        2119                 :            : were backed up to disk.
        2120                 :            : [clinic start generated code]*/
        2121                 :            :
        2122                 :            : static PyObject *
        2123                 :            : serialize_impl(pysqlite_Connection *self, const char *name)
        2124                 :            : /*[clinic end generated code: output=97342b0e55239dd3 input=d2eb5194a65abe2b]*/
        2125                 :            : {
        2126                 :            :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        2127                 :            :         return NULL;
        2128                 :            :     }
        2129                 :            :
        2130                 :            :     /* If SQLite has a contiguous memory representation of the database, we can
        2131                 :            :      * avoid memory allocations, so we try with the no-copy flag first.
        2132                 :            :      */
        2133                 :            :     sqlite3_int64 size;
        2134                 :            :     unsigned int flags = SQLITE_SERIALIZE_NOCOPY;
        2135                 :            :     const char *data;
        2136                 :            :
        2137                 :            :     Py_BEGIN_ALLOW_THREADS
        2138                 :            :     data = (const char *)sqlite3_serialize(self->db, name, &size, flags);
        2139                 :            :     if (data == NULL) {
        2140                 :            :         flags &= ~SQLITE_SERIALIZE_NOCOPY;
        2141                 :            :         data = (const char *)sqlite3_serialize(self->db, name, &size, flags);
        2142                 :            :     }
        2143                 :            :     Py_END_ALLOW_THREADS
        2144                 :            :
        2145                 :            :     if (data == NULL) {
        2146                 :            :         PyErr_Format(self->OperationalError, "unable to serialize '%s'",
        2147                 :            :                      name);
        2148                 :            :         return NULL;
        2149                 :            :     }
        2150                 :            :     PyObject *res = PyBytes_FromStringAndSize(data, (Py_ssize_t)size);
        2151                 :            :     if (!(flags & SQLITE_SERIALIZE_NOCOPY)) {
        2152                 :            :         sqlite3_free((void *)data);
        2153                 :            :     }
        2154                 :            :     return res;
        2155                 :            : }
        2156                 :            :
        2157                 :            : /*[clinic input]
        2158                 :            : _sqlite3.Connection.deserialize as deserialize
        2159                 :            :
        2160                 :            :     data: Py_buffer(accept={buffer, str})
        2161                 :            :         The serialized database content.
        2162                 :            :     /
        2163                 :            :     *
        2164                 :            :     name: str = "main"
        2165                 :            :         Which database to reopen with the deserialization.
        2166                 :            :
        2167                 :            : Load a serialized database.
        2168                 :            :
        2169                 :            : The deserialize interface causes the database connection to disconnect from the
        2170                 :            : target database, and then reopen it as an in-memory database based on the given
        2171                 :            : serialized data.
        2172                 :            :
        2173                 :            : The deserialize interface will fail with SQLITE_BUSY if the database is
        2174                 :            : currently in a read transaction or is involved in a backup operation.
        2175                 :            : [clinic start generated code]*/
        2176                 :            :
        2177                 :            : static PyObject *
        2178                 :            : deserialize_impl(pysqlite_Connection *self, Py_buffer *data,
        2179                 :            :                  const char *name)
        2180                 :            : /*[clinic end generated code: output=e394c798b98bad89 input=1be4ca1faacf28f2]*/
        2181                 :            : {
        2182                 :            :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        2183                 :            :         return NULL;
        2184                 :            :     }
        2185                 :            :
        2186                 :            :     /* Transfer ownership of the buffer to SQLite:
        2187                 :            :      * - Move buffer from Py to SQLite
        2188                 :            :      * - Tell SQLite to free buffer memory
        2189                 :            :      * - Tell SQLite that it is permitted to grow the resulting database
        2190                 :            :      *
        2191                 :            :      * Make sure we don't overflow sqlite3_deserialize(); it accepts a signed
        2192                 :            :      * 64-bit int as its data size argument.
        2193                 :            :      *
        2194                 :            :      * We can safely use sqlite3_malloc64 here, since it was introduced before
        2195                 :            :      * the serialize APIs.
        2196                 :            :      */
        2197                 :            :     if (data->len > 9223372036854775807) {  // (1 << 63) - 1
        2198                 :            :         PyErr_SetString(PyExc_OverflowError, "'data' is too large");
        2199                 :            :         return NULL;
        2200                 :            :     }
        2201                 :            :
        2202                 :            :     sqlite3_int64 size = (sqlite3_int64)data->len;
        2203                 :            :     unsigned char *buf = sqlite3_malloc64(size);
        2204                 :            :     if (buf == NULL) {
        2205                 :            :         return PyErr_NoMemory();
        2206                 :            :     }
        2207                 :            :
        2208                 :            :     const unsigned int flags = SQLITE_DESERIALIZE_FREEONCLOSE |
        2209                 :            :                                SQLITE_DESERIALIZE_RESIZEABLE;
        2210                 :            :     int rc;
        2211                 :            :     Py_BEGIN_ALLOW_THREADS
        2212                 :            :     (void)memcpy(buf, data->buf, data->len);
        2213                 :            :     rc = sqlite3_deserialize(self->db, name, buf, size, size, flags);
        2214                 :            :     Py_END_ALLOW_THREADS
        2215                 :            :
        2216                 :            :     if (rc != SQLITE_OK) {
        2217                 :            :         (void)_pysqlite_seterror(self->state, self->db);
        2218                 :            :         return NULL;
        2219                 :            :     }
        2220                 :            :     Py_RETURN_NONE;
        2221                 :            : }
        2222                 :            : #endif  // PY_SQLITE_HAVE_SERIALIZE
        2223                 :            :
        2224                 :            :
        2225                 :            : /*[clinic input]
        2226                 :            : _sqlite3.Connection.__enter__ as pysqlite_connection_enter
        2227                 :            :
        2228                 :            : Called when the connection is used as a context manager.
        2229                 :            :
        2230                 :            : Returns itself as a convenience to the caller.
        2231                 :            : [clinic start generated code]*/
        2232                 :            :
        2233                 :            : static PyObject *
        2234                 :          0 : pysqlite_connection_enter_impl(pysqlite_Connection *self)
        2235                 :            : /*[clinic end generated code: output=457b09726d3e9dcd input=127d7a4f17e86d8f]*/
        2236                 :            : {
        2237         [ #  # ]:          0 :     if (!pysqlite_check_connection(self)) {
        2238                 :          0 :         return NULL;
        2239                 :            :     }
        2240                 :          0 :     return Py_NewRef((PyObject *)self);
        2241                 :            : }
        2242                 :            :
        2243                 :            : /*[clinic input]
        2244                 :            : _sqlite3.Connection.__exit__ as pysqlite_connection_exit
        2245                 :            :
        2246                 :            :     type as exc_type: object
        2247                 :            :     value as exc_value: object
        2248                 :            :     traceback as exc_tb: object
        2249                 :            :     /
        2250                 :            :
        2251                 :            : Called when the connection is used as a context manager.
        2252                 :            :
        2253                 :            : If there was any exception, a rollback takes place; otherwise we commit.
        2254                 :            : [clinic start generated code]*/
        2255                 :            :
        2256                 :            : static PyObject *
        2257                 :          0 : pysqlite_connection_exit_impl(pysqlite_Connection *self, PyObject *exc_type,
        2258                 :            :                               PyObject *exc_value, PyObject *exc_tb)
        2259                 :            : /*[clinic end generated code: output=0705200e9321202a input=bd66f1532c9c54a7]*/
        2260                 :            : {
        2261                 :          0 :     int commit = 0;
        2262                 :            :     PyObject* result;
        2263                 :            :
        2264   [ #  #  #  #  :          0 :     if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
                       #  # ]
        2265                 :          0 :         commit = 1;
        2266                 :          0 :         result = pysqlite_connection_commit_impl(self);
        2267                 :            :     }
        2268                 :            :     else {
        2269                 :          0 :         result = pysqlite_connection_rollback_impl(self);
        2270                 :            :     }
        2271                 :            :
        2272         [ #  # ]:          0 :     if (result == NULL) {
        2273         [ #  # ]:          0 :         if (commit) {
        2274                 :            :             /* Commit failed; try to rollback in order to unlock the database.
        2275                 :            :              * If rollback also fails, chain the exceptions. */
        2276                 :          0 :             PyObject *exc = PyErr_GetRaisedException();
        2277                 :          0 :             result = pysqlite_connection_rollback_impl(self);
        2278         [ #  # ]:          0 :             if (result == NULL) {
        2279                 :          0 :                 _PyErr_ChainExceptions1(exc);
        2280                 :            :             }
        2281                 :            :             else {
        2282                 :          0 :                 Py_DECREF(result);
        2283                 :          0 :                 PyErr_SetRaisedException(exc);
        2284                 :            :             }
        2285                 :            :         }
        2286                 :          0 :         return NULL;
        2287                 :            :     }
        2288                 :          0 :     Py_DECREF(result);
        2289                 :            :
        2290                 :          0 :     Py_RETURN_FALSE;
        2291                 :            : }
        2292                 :            :
        2293                 :            : /*[clinic input]
        2294                 :            : _sqlite3.Connection.setlimit as setlimit
        2295                 :            :
        2296                 :            :     category: int
        2297                 :            :         The limit category to be set.
        2298                 :            :     limit: int
        2299                 :            :         The new limit. If the new limit is a negative number, the limit is
        2300                 :            :         unchanged.
        2301                 :            :     /
        2302                 :            :
        2303                 :            : Set connection run-time limits.
        2304                 :            :
        2305                 :            : Attempts to increase a limit above its hard upper bound are silently truncated
        2306                 :            : to the hard upper bound. Regardless of whether or not the limit was changed,
        2307                 :            : the prior value of the limit is returned.
        2308                 :            : [clinic start generated code]*/
        2309                 :            :
        2310                 :            : static PyObject *
        2311                 :          0 : setlimit_impl(pysqlite_Connection *self, int category, int limit)
        2312                 :            : /*[clinic end generated code: output=0d208213f8d68ccd input=9bd469537e195635]*/
        2313                 :            : {
        2314   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        2315                 :          0 :         return NULL;
        2316                 :            :     }
        2317                 :            :
        2318                 :          0 :     int old_limit = sqlite3_limit(self->db, category, limit);
        2319         [ #  # ]:          0 :     if (old_limit < 0) {
        2320                 :          0 :         PyErr_SetString(self->ProgrammingError, "'category' is out of bounds");
        2321                 :          0 :         return NULL;
        2322                 :            :     }
        2323                 :          0 :     return PyLong_FromLong(old_limit);
        2324                 :            : }
        2325                 :            :
        2326                 :            : /*[clinic input]
        2327                 :            : _sqlite3.Connection.getlimit as getlimit
        2328                 :            :
        2329                 :            :     category: int
        2330                 :            :         The limit category to be queried.
        2331                 :            :     /
        2332                 :            :
        2333                 :            : Get connection run-time limits.
        2334                 :            : [clinic start generated code]*/
        2335                 :            :
        2336                 :            : static PyObject *
        2337                 :          0 : getlimit_impl(pysqlite_Connection *self, int category)
        2338                 :            : /*[clinic end generated code: output=7c3f5d11f24cecb1 input=61e0849fb4fb058f]*/
        2339                 :            : {
        2340                 :          0 :     return setlimit_impl(self, category, -1);
        2341                 :            : }
        2342                 :            :
        2343                 :            :
        2344                 :            : static PyObject *
        2345                 :          0 : get_autocommit(pysqlite_Connection *self, void *Py_UNUSED(ctx))
        2346                 :            : {
        2347   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        2348                 :          0 :         return NULL;
        2349                 :            :     }
        2350         [ #  # ]:          0 :     if (self->autocommit == AUTOCOMMIT_ENABLED) {
        2351                 :          0 :         Py_RETURN_TRUE;
        2352                 :            :     }
        2353         [ #  # ]:          0 :     if (self->autocommit == AUTOCOMMIT_DISABLED) {
        2354                 :          0 :         Py_RETURN_FALSE;
        2355                 :            :     }
        2356                 :          0 :     return PyLong_FromLong(LEGACY_TRANSACTION_CONTROL);
        2357                 :            : }
        2358                 :            :
        2359                 :            : static int
        2360                 :          0 : set_autocommit(pysqlite_Connection *self, PyObject *val, void *Py_UNUSED(ctx))
        2361                 :            : {
        2362   [ #  #  #  # ]:          0 :     if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
        2363                 :          0 :         return -1;
        2364                 :            :     }
        2365         [ #  # ]:          0 :     if (!autocommit_converter(val, &self->autocommit)) {
        2366                 :          0 :         return -1;
        2367                 :            :     }
        2368         [ #  # ]:          0 :     if (self->autocommit == AUTOCOMMIT_ENABLED) {
        2369         [ #  # ]:          0 :         if (!sqlite3_get_autocommit(self->db)) {
        2370         [ #  # ]:          0 :             if (connection_exec_stmt(self, "COMMIT") < 0) {
        2371                 :          0 :                 return -1;
        2372                 :            :             }
        2373                 :            :         }
        2374                 :            :     }
        2375         [ #  # ]:          0 :     else if (self->autocommit == AUTOCOMMIT_DISABLED) {
        2376         [ #  # ]:          0 :         if (sqlite3_get_autocommit(self->db)) {
        2377         [ #  # ]:          0 :             if (connection_exec_stmt(self, "BEGIN") < 0) {
        2378                 :          0 :                 return -1;
        2379                 :            :             }
        2380                 :            :         }
        2381                 :            :     }
        2382                 :          0 :     return 0;
        2383                 :            : }
        2384                 :            :
        2385                 :            :
        2386                 :            : static const char connection_doc[] =
        2387                 :            : PyDoc_STR("SQLite database connection object.");
        2388                 :            :
        2389                 :            : static PyGetSetDef connection_getset[] = {
        2390                 :            :     {"isolation_level",  (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
        2391                 :            :     {"total_changes",  (getter)pysqlite_connection_get_total_changes, (setter)0},
        2392                 :            :     {"in_transaction",  (getter)pysqlite_connection_get_in_transaction, (setter)0},
        2393                 :            :     {"autocommit",  (getter)get_autocommit, (setter)set_autocommit},
        2394                 :            :     {NULL}
        2395                 :            : };
        2396                 :            :
        2397                 :            : static PyMethodDef connection_methods[] = {
        2398                 :            :     PYSQLITE_CONNECTION_BACKUP_METHODDEF
        2399                 :            :     PYSQLITE_CONNECTION_CLOSE_METHODDEF
        2400                 :            :     PYSQLITE_CONNECTION_COMMIT_METHODDEF
        2401                 :            :     PYSQLITE_CONNECTION_CREATE_AGGREGATE_METHODDEF
        2402                 :            :     PYSQLITE_CONNECTION_CREATE_COLLATION_METHODDEF
        2403                 :            :     PYSQLITE_CONNECTION_CREATE_FUNCTION_METHODDEF
        2404                 :            :     PYSQLITE_CONNECTION_CURSOR_METHODDEF
        2405                 :            :     PYSQLITE_CONNECTION_ENABLE_LOAD_EXTENSION_METHODDEF
        2406                 :            :     PYSQLITE_CONNECTION_ENTER_METHODDEF
        2407                 :            :     PYSQLITE_CONNECTION_EXECUTEMANY_METHODDEF
        2408                 :            :     PYSQLITE_CONNECTION_EXECUTESCRIPT_METHODDEF
        2409                 :            :     PYSQLITE_CONNECTION_EXECUTE_METHODDEF
        2410                 :            :     PYSQLITE_CONNECTION_EXIT_METHODDEF
        2411                 :            :     PYSQLITE_CONNECTION_INTERRUPT_METHODDEF
        2412                 :            :     PYSQLITE_CONNECTION_ITERDUMP_METHODDEF
        2413                 :            :     PYSQLITE_CONNECTION_LOAD_EXTENSION_METHODDEF
        2414                 :            :     PYSQLITE_CONNECTION_ROLLBACK_METHODDEF
        2415                 :            :     PYSQLITE_CONNECTION_SET_AUTHORIZER_METHODDEF
        2416                 :            :     PYSQLITE_CONNECTION_SET_PROGRESS_HANDLER_METHODDEF
        2417                 :            :     PYSQLITE_CONNECTION_SET_TRACE_CALLBACK_METHODDEF
        2418                 :            :     SETLIMIT_METHODDEF
        2419                 :            :     GETLIMIT_METHODDEF
        2420                 :            :     SERIALIZE_METHODDEF
        2421                 :            :     DESERIALIZE_METHODDEF
        2422                 :            :     CREATE_WINDOW_FUNCTION_METHODDEF
        2423                 :            :     BLOBOPEN_METHODDEF
        2424                 :            :     {NULL, NULL}
        2425                 :            : };
        2426                 :            :
        2427                 :            : static struct PyMemberDef connection_members[] =
        2428                 :            : {
        2429                 :            :     {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), READONLY},
        2430                 :            :     {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), READONLY},
        2431                 :            :     {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), READONLY},
        2432                 :            :     {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), READONLY},
        2433                 :            :     {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), READONLY},
        2434                 :            :     {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), READONLY},
        2435                 :            :     {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), READONLY},
        2436                 :            :     {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), READONLY},
        2437                 :            :     {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), READONLY},
        2438                 :            :     {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), READONLY},
        2439                 :            :     {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)},
        2440                 :            :     {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)},
        2441                 :            :     {NULL}
        2442                 :            : };
        2443                 :            :
        2444                 :            : static PyType_Slot connection_slots[] = {
        2445                 :            :     {Py_tp_dealloc, connection_dealloc},
        2446                 :            :     {Py_tp_doc, (void *)connection_doc},
        2447                 :            :     {Py_tp_methods, connection_methods},
        2448                 :            :     {Py_tp_members, connection_members},
        2449                 :            :     {Py_tp_getset, connection_getset},
        2450                 :            :     {Py_tp_init, pysqlite_connection_init},
        2451                 :            :     {Py_tp_call, pysqlite_connection_call},
        2452                 :            :     {Py_tp_traverse, connection_traverse},
        2453                 :            :     {Py_tp_clear, connection_clear},
        2454                 :            :     {0, NULL},
        2455                 :            : };
        2456                 :            :
        2457                 :            : static PyType_Spec connection_spec = {
        2458                 :            :     .name = MODULE_NAME ".Connection",
        2459                 :            :     .basicsize = sizeof(pysqlite_Connection),
        2460                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
        2461                 :            :               Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
        2462                 :            :     .slots = connection_slots,
        2463                 :            : };
        2464                 :            :
        2465                 :            : int
        2466                 :          1 : pysqlite_connection_setup_types(PyObject *module)
        2467                 :            : {
        2468                 :          1 :     PyObject *type = PyType_FromModuleAndSpec(module, &connection_spec, NULL);
        2469         [ -  + ]:          1 :     if (type == NULL) {
        2470                 :          0 :         return -1;
        2471                 :            :     }
        2472                 :          1 :     pysqlite_state *state = pysqlite_get_state(module);
        2473                 :          1 :     state->ConnectionType = (PyTypeObject *)type;
        2474                 :          1 :     return 0;
        2475                 :            : }

Generated by: LCOV version 1.14