LCOV - code coverage report
Current view: | top level - Modules/_sqlite - module.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 175 | 256 | 68.4 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 10 | 17 | 58.8 %
|  |  | Branches: | 198 | 370 | 53.5 %

               Branch data     Line data    Source code
           1                 :            : /* module.c - the module itself
           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 "connection.h"
          25                 :            : #include "statement.h"
          26                 :            : #include "cursor.h"
          27                 :            : #include "prepare_protocol.h"
          28                 :            : #include "microprotocols.h"
          29                 :            : #include "row.h"
          30                 :            : #include "blob.h"
          31                 :            :
          32                 :            : #if SQLITE_VERSION_NUMBER < 3007015
          33                 :            : #error "SQLite 3.7.15 or higher required"
          34                 :            : #endif
          35                 :            :
          36                 :            : #define clinic_state() (pysqlite_get_state(module))
          37                 :            : #include "clinic/module.c.h"
          38                 :            : #undef clinic_state
          39                 :            :
          40                 :            : /*[clinic input]
          41                 :            : module _sqlite3
          42                 :            : [clinic start generated code]*/
          43                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=81e330492d57488e]*/
          44                 :            :
          45                 :            : // NB: This needs to be in sync with the Connection.__init__ docstring.
          46                 :            : PyDoc_STRVAR(module_connect_doc,
          47                 :            : "connect($module, /, database, timeout=5.0, detect_types=0,\n"
          48                 :            : "        isolation_level='', check_same_thread=True,\n"
          49                 :            : "        factory=ConnectionType, cached_statements=128, uri=False, *,\n"
          50                 :            : "        autocommit=sqlite3.LEGACY_TRANSACTION_CONTROL)\n"
          51                 :            : "--\n"
          52                 :            : "\n"
          53                 :            : "Opens a connection to the SQLite database file database.\n"
          54                 :            : "\n"
          55                 :            : "You can use \":memory:\" to open a database connection to a database that resides\n"
          56                 :            : "in RAM instead of on disk.");
          57                 :            :
          58                 :            : #define PYSQLITE_CONNECT_METHODDEF    \
          59                 :            :     {"connect", _PyCFunction_CAST(module_connect), METH_FASTCALL|METH_KEYWORDS, module_connect_doc},
          60                 :            :
          61                 :            : static PyObject *
          62                 :          0 : module_connect(PyObject *module, PyObject *const *args, Py_ssize_t nargsf,
          63                 :            :                PyObject *kwnames)
          64                 :            : {
          65                 :          0 :     pysqlite_state *state = pysqlite_get_state(module);
          66                 :          0 :     PyObject *factory = (PyObject *)state->ConnectionType;
          67                 :            :
          68                 :            :     static const int FACTORY_POS = 5;
          69                 :          0 :     Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
          70         [ #  # ]:          0 :     if (nargs > FACTORY_POS) {
          71                 :          0 :         factory = args[FACTORY_POS];
          72                 :            :     }
          73         [ #  # ]:          0 :     else if (kwnames != NULL) {
          74         [ #  # ]:          0 :         for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(kwnames); i++) {
          75                 :          0 :             PyObject *item = PyTuple_GET_ITEM(kwnames, i);  // borrowed ref.
          76         [ #  # ]:          0 :             if (PyUnicode_CompareWithASCIIString(item, "factory") == 0) {
          77                 :          0 :                 factory = args[nargs + i];
          78                 :          0 :                 break;
          79                 :            :             }
          80                 :            :         }
          81                 :            :     }
          82                 :            :
          83                 :          0 :     return PyObject_Vectorcall(factory, args, nargsf, kwnames);
          84                 :            : }
          85                 :            :
          86                 :            : /*[clinic input]
          87                 :            : _sqlite3.complete_statement as pysqlite_complete_statement
          88                 :            :
          89                 :            :     statement: str
          90                 :            :
          91                 :            : Checks if a string contains a complete SQL statement.
          92                 :            : [clinic start generated code]*/
          93                 :            :
          94                 :            : static PyObject *
          95                 :          0 : pysqlite_complete_statement_impl(PyObject *module, const char *statement)
          96                 :            : /*[clinic end generated code: output=e55f1ff1952df558 input=ac45d257375bb828]*/
          97                 :            : {
          98         [ #  # ]:          0 :     if (sqlite3_complete(statement)) {
          99                 :          0 :         return Py_NewRef(Py_True);
         100                 :            :     } else {
         101                 :          0 :         return Py_NewRef(Py_False);
         102                 :            :     }
         103                 :            : }
         104                 :            :
         105                 :            : /*[clinic input]
         106                 :            : _sqlite3.register_adapter as pysqlite_register_adapter
         107                 :            :
         108                 :            :     type: object(type='PyTypeObject *')
         109                 :            :     adapter as caster: object
         110                 :            :     /
         111                 :            :
         112                 :            : Register a function to adapt Python objects to SQLite values.
         113                 :            : [clinic start generated code]*/
         114                 :            :
         115                 :            : static PyObject *
         116                 :          0 : pysqlite_register_adapter_impl(PyObject *module, PyTypeObject *type,
         117                 :            :                                PyObject *caster)
         118                 :            : /*[clinic end generated code: output=a287e8db18e8af23 input=29a5e0f213030242]*/
         119                 :            : {
         120                 :            :     int rc;
         121                 :            :
         122                 :            :     /* a basic type is adapted; there's a performance optimization if that's not the case
         123                 :            :      * (99 % of all usages) */
         124   [ #  #  #  # ]:          0 :     if (type == &PyLong_Type || type == &PyFloat_Type
         125   [ #  #  #  # ]:          0 :             || type == &PyUnicode_Type || type == &PyByteArray_Type) {
         126                 :          0 :         pysqlite_state *state = pysqlite_get_state(module);
         127                 :          0 :         state->BaseTypeAdapted = 1;
         128                 :            :     }
         129                 :            :
         130                 :          0 :     pysqlite_state *state = pysqlite_get_state(module);
         131                 :          0 :     PyObject *protocol = (PyObject *)state->PrepareProtocolType;
         132                 :          0 :     rc = pysqlite_microprotocols_add(state, type, protocol, caster);
         133         [ #  # ]:          0 :     if (rc == -1) {
         134                 :          0 :         return NULL;
         135                 :            :     }
         136                 :            :
         137                 :          0 :     Py_RETURN_NONE;
         138                 :            : }
         139                 :            :
         140                 :            : /*[clinic input]
         141                 :            : _sqlite3.register_converter as pysqlite_register_converter
         142                 :            :
         143                 :            :     typename as orig_name: unicode
         144                 :            :     converter as callable: object
         145                 :            :     /
         146                 :            :
         147                 :            : Register a function to convert SQLite values to Python objects.
         148                 :            : [clinic start generated code]*/
         149                 :            :
         150                 :            : static PyObject *
         151                 :          0 : pysqlite_register_converter_impl(PyObject *module, PyObject *orig_name,
         152                 :            :                                  PyObject *callable)
         153                 :            : /*[clinic end generated code: output=a2f2bfeed7230062 input=159a444971b40378]*/
         154                 :            : {
         155                 :          0 :     PyObject* name = NULL;
         156                 :          0 :     PyObject* retval = NULL;
         157                 :            :
         158                 :            :     /* convert the name to upper case */
         159                 :          0 :     pysqlite_state *state = pysqlite_get_state(module);
         160                 :          0 :     name = PyObject_CallMethodNoArgs(orig_name, state->str_upper);
         161         [ #  # ]:          0 :     if (!name) {
         162                 :          0 :         goto error;
         163                 :            :     }
         164                 :            :
         165         [ #  # ]:          0 :     if (PyDict_SetItem(state->converters, name, callable) != 0) {
         166                 :          0 :         goto error;
         167                 :            :     }
         168                 :            :
         169                 :          0 :     retval = Py_NewRef(Py_None);
         170                 :          0 : error:
         171                 :          0 :     Py_XDECREF(name);
         172                 :          0 :     return retval;
         173                 :            : }
         174                 :            :
         175                 :            : /*[clinic input]
         176                 :            : _sqlite3.enable_callback_tracebacks as pysqlite_enable_callback_trace
         177                 :            :
         178                 :            :     enable: int
         179                 :            :     /
         180                 :            :
         181                 :            : Enable or disable callback functions throwing errors to stderr.
         182                 :            : [clinic start generated code]*/
         183                 :            :
         184                 :            : static PyObject *
         185                 :          0 : pysqlite_enable_callback_trace_impl(PyObject *module, int enable)
         186                 :            : /*[clinic end generated code: output=4ff1d051c698f194 input=cb79d3581eb77c40]*/
         187                 :            : {
         188                 :          0 :     pysqlite_state *state = pysqlite_get_state(module);
         189                 :          0 :     state->enable_callback_tracebacks = enable;
         190                 :            :
         191                 :          0 :     Py_RETURN_NONE;
         192                 :            : }
         193                 :            :
         194                 :            : /*[clinic input]
         195                 :            : _sqlite3.adapt as pysqlite_adapt
         196                 :            :
         197                 :            :     obj: object
         198                 :            :     proto: object(c_default='(PyObject *)clinic_state()->PrepareProtocolType') = PrepareProtocolType
         199                 :            :     alt: object = NULL
         200                 :            :     /
         201                 :            :
         202                 :            : Adapt given object to given protocol.
         203                 :            : [clinic start generated code]*/
         204                 :            :
         205                 :            : static PyObject *
         206                 :          0 : pysqlite_adapt_impl(PyObject *module, PyObject *obj, PyObject *proto,
         207                 :            :                     PyObject *alt)
         208                 :            : /*[clinic end generated code: output=0c3927c5fcd23dd9 input=a53dc9993e81e15f]*/
         209                 :            : {
         210                 :          0 :     pysqlite_state *state = pysqlite_get_state(module);
         211                 :          0 :     return pysqlite_microprotocols_adapt(state, obj, proto, alt);
         212                 :            : }
         213                 :            :
         214                 :          1 : static int converters_init(PyObject* module)
         215                 :            : {
         216                 :          1 :     pysqlite_state *state = pysqlite_get_state(module);
         217                 :          1 :     state->converters = PyDict_New();
         218         [ -  + ]:          1 :     if (state->converters == NULL) {
         219                 :          0 :         return -1;
         220                 :            :     }
         221                 :            :
         222                 :          1 :     return PyModule_AddObjectRef(module, "converters", state->converters);
         223                 :            : }
         224                 :            :
         225                 :            : static int
         226                 :          1 : load_functools_lru_cache(PyObject *module)
         227                 :            : {
         228                 :          1 :     pysqlite_state *state = pysqlite_get_state(module);
         229                 :          1 :     state->lru_cache = _PyImport_GetModuleAttrString("functools", "lru_cache");
         230         [ -  + ]:          1 :     if (state->lru_cache == NULL) {
         231                 :          0 :         return -1;
         232                 :            :     }
         233                 :          1 :     return 0;
         234                 :            : }
         235                 :            :
         236                 :            : static PyMethodDef module_methods[] = {
         237                 :            :     PYSQLITE_ADAPT_METHODDEF
         238                 :            :     PYSQLITE_COMPLETE_STATEMENT_METHODDEF
         239                 :            :     PYSQLITE_CONNECT_METHODDEF
         240                 :            :     PYSQLITE_ENABLE_CALLBACK_TRACE_METHODDEF
         241                 :            :     PYSQLITE_REGISTER_ADAPTER_METHODDEF
         242                 :            :     PYSQLITE_REGISTER_CONVERTER_METHODDEF
         243                 :            :     {NULL, NULL}
         244                 :            : };
         245                 :            :
         246                 :            : /* SQLite C API result codes. See also:
         247                 :            :  * - https://www.sqlite.org/c3ref/c_abort_rollback.html
         248                 :            :  * - https://sqlite.org/changes.html#version_3_3_8
         249                 :            :  * - https://sqlite.org/changes.html#version_3_7_16
         250                 :            :  * - https://sqlite.org/changes.html#version_3_7_17
         251                 :            :  * - https://sqlite.org/changes.html#version_3_8_0
         252                 :            :  * - https://sqlite.org/changes.html#version_3_8_3
         253                 :            :  * - https://sqlite.org/changes.html#version_3_14
         254                 :            :  *
         255                 :            :  * Note: the SQLite changelogs rarely mention new result codes, so in order to
         256                 :            :  * keep the 'error_codes' table in sync with SQLite, we must manually inspect
         257                 :            :  * sqlite3.h for every release.
         258                 :            :  *
         259                 :            :  * We keep the SQLITE_VERSION_NUMBER checks in order to easily declutter the
         260                 :            :  * code when we adjust the SQLite version requirement.
         261                 :            :  */
         262                 :            : static const struct {
         263                 :            :     const char *name;
         264                 :            :     long value;
         265                 :            : } error_codes[] = {
         266                 :            : #define DECLARE_ERROR_CODE(code) {#code, code}
         267                 :            :     // Primary result code list
         268                 :            :     DECLARE_ERROR_CODE(SQLITE_ABORT),
         269                 :            :     DECLARE_ERROR_CODE(SQLITE_AUTH),
         270                 :            :     DECLARE_ERROR_CODE(SQLITE_BUSY),
         271                 :            :     DECLARE_ERROR_CODE(SQLITE_CANTOPEN),
         272                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT),
         273                 :            :     DECLARE_ERROR_CODE(SQLITE_CORRUPT),
         274                 :            :     DECLARE_ERROR_CODE(SQLITE_DONE),
         275                 :            :     DECLARE_ERROR_CODE(SQLITE_EMPTY),
         276                 :            :     DECLARE_ERROR_CODE(SQLITE_ERROR),
         277                 :            :     DECLARE_ERROR_CODE(SQLITE_FORMAT),
         278                 :            :     DECLARE_ERROR_CODE(SQLITE_FULL),
         279                 :            :     DECLARE_ERROR_CODE(SQLITE_INTERNAL),
         280                 :            :     DECLARE_ERROR_CODE(SQLITE_INTERRUPT),
         281                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR),
         282                 :            :     DECLARE_ERROR_CODE(SQLITE_LOCKED),
         283                 :            :     DECLARE_ERROR_CODE(SQLITE_MISMATCH),
         284                 :            :     DECLARE_ERROR_CODE(SQLITE_MISUSE),
         285                 :            :     DECLARE_ERROR_CODE(SQLITE_NOLFS),
         286                 :            :     DECLARE_ERROR_CODE(SQLITE_NOMEM),
         287                 :            :     DECLARE_ERROR_CODE(SQLITE_NOTADB),
         288                 :            :     DECLARE_ERROR_CODE(SQLITE_NOTFOUND),
         289                 :            :     DECLARE_ERROR_CODE(SQLITE_OK),
         290                 :            :     DECLARE_ERROR_CODE(SQLITE_PERM),
         291                 :            :     DECLARE_ERROR_CODE(SQLITE_PROTOCOL),
         292                 :            :     DECLARE_ERROR_CODE(SQLITE_RANGE),
         293                 :            :     DECLARE_ERROR_CODE(SQLITE_READONLY),
         294                 :            :     DECLARE_ERROR_CODE(SQLITE_ROW),
         295                 :            :     DECLARE_ERROR_CODE(SQLITE_SCHEMA),
         296                 :            :     DECLARE_ERROR_CODE(SQLITE_TOOBIG),
         297                 :            : #if SQLITE_VERSION_NUMBER >= 3007017
         298                 :            :     DECLARE_ERROR_CODE(SQLITE_NOTICE),
         299                 :            :     DECLARE_ERROR_CODE(SQLITE_WARNING),
         300                 :            : #endif
         301                 :            :     // Extended result code list
         302                 :            :     DECLARE_ERROR_CODE(SQLITE_ABORT_ROLLBACK),
         303                 :            :     DECLARE_ERROR_CODE(SQLITE_BUSY_RECOVERY),
         304                 :            :     DECLARE_ERROR_CODE(SQLITE_CANTOPEN_FULLPATH),
         305                 :            :     DECLARE_ERROR_CODE(SQLITE_CANTOPEN_ISDIR),
         306                 :            :     DECLARE_ERROR_CODE(SQLITE_CANTOPEN_NOTEMPDIR),
         307                 :            :     DECLARE_ERROR_CODE(SQLITE_CORRUPT_VTAB),
         308                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_ACCESS),
         309                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_BLOCKED),
         310                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_CHECKRESERVEDLOCK),
         311                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_CLOSE),
         312                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_DELETE),
         313                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_DELETE_NOENT),
         314                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_DIR_CLOSE),
         315                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_DIR_FSYNC),
         316                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_FSTAT),
         317                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_FSYNC),
         318                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_LOCK),
         319                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_NOMEM),
         320                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_RDLOCK),
         321                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_READ),
         322                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_SEEK),
         323                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_SHMLOCK),
         324                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_SHMMAP),
         325                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_SHMOPEN),
         326                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_SHMSIZE),
         327                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_SHORT_READ),
         328                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_TRUNCATE),
         329                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_UNLOCK),
         330                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_WRITE),
         331                 :            :     DECLARE_ERROR_CODE(SQLITE_LOCKED_SHAREDCACHE),
         332                 :            :     DECLARE_ERROR_CODE(SQLITE_READONLY_CANTLOCK),
         333                 :            :     DECLARE_ERROR_CODE(SQLITE_READONLY_RECOVERY),
         334                 :            : #if SQLITE_VERSION_NUMBER >= 3007016
         335                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_CHECK),
         336                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_COMMITHOOK),
         337                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_FOREIGNKEY),
         338                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_FUNCTION),
         339                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_NOTNULL),
         340                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_PRIMARYKEY),
         341                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_TRIGGER),
         342                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_UNIQUE),
         343                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_VTAB),
         344                 :            :     DECLARE_ERROR_CODE(SQLITE_READONLY_ROLLBACK),
         345                 :            : #endif
         346                 :            : #if SQLITE_VERSION_NUMBER >= 3007017
         347                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_MMAP),
         348                 :            :     DECLARE_ERROR_CODE(SQLITE_NOTICE_RECOVER_ROLLBACK),
         349                 :            :     DECLARE_ERROR_CODE(SQLITE_NOTICE_RECOVER_WAL),
         350                 :            : #endif
         351                 :            : #if SQLITE_VERSION_NUMBER >= 3008000
         352                 :            :     DECLARE_ERROR_CODE(SQLITE_BUSY_SNAPSHOT),
         353                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_GETTEMPPATH),
         354                 :            :     DECLARE_ERROR_CODE(SQLITE_WARNING_AUTOINDEX),
         355                 :            : #endif
         356                 :            : #if SQLITE_VERSION_NUMBER >= 3008001
         357                 :            :     DECLARE_ERROR_CODE(SQLITE_CANTOPEN_CONVPATH),
         358                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_CONVPATH),
         359                 :            : #endif
         360                 :            : #if SQLITE_VERSION_NUMBER >= 3008002
         361                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_ROWID),
         362                 :            : #endif
         363                 :            : #if SQLITE_VERSION_NUMBER >= 3008003
         364                 :            :     DECLARE_ERROR_CODE(SQLITE_READONLY_DBMOVED),
         365                 :            : #endif
         366                 :            : #if SQLITE_VERSION_NUMBER >= 3008007
         367                 :            :     DECLARE_ERROR_CODE(SQLITE_AUTH_USER),
         368                 :            : #endif
         369                 :            : #if SQLITE_VERSION_NUMBER >= 3009000
         370                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_VNODE),
         371                 :            : #endif
         372                 :            : #if SQLITE_VERSION_NUMBER >= 3010000
         373                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_AUTH),
         374                 :            : #endif
         375                 :            : #if SQLITE_VERSION_NUMBER >= 3014001
         376                 :            :     DECLARE_ERROR_CODE(SQLITE_OK_LOAD_PERMANENTLY),
         377                 :            : #endif
         378                 :            : #if SQLITE_VERSION_NUMBER >= 3021000
         379                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_BEGIN_ATOMIC),
         380                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_COMMIT_ATOMIC),
         381                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_ROLLBACK_ATOMIC),
         382                 :            : #endif
         383                 :            : #if SQLITE_VERSION_NUMBER >= 3022000
         384                 :            :     DECLARE_ERROR_CODE(SQLITE_ERROR_MISSING_COLLSEQ),
         385                 :            :     DECLARE_ERROR_CODE(SQLITE_ERROR_RETRY),
         386                 :            :     DECLARE_ERROR_CODE(SQLITE_READONLY_CANTINIT),
         387                 :            :     DECLARE_ERROR_CODE(SQLITE_READONLY_DIRECTORY),
         388                 :            : #endif
         389                 :            : #if SQLITE_VERSION_NUMBER >= 3024000
         390                 :            :     DECLARE_ERROR_CODE(SQLITE_CORRUPT_SEQUENCE),
         391                 :            :     DECLARE_ERROR_CODE(SQLITE_LOCKED_VTAB),
         392                 :            : #endif
         393                 :            : #if SQLITE_VERSION_NUMBER >= 3025000
         394                 :            :     DECLARE_ERROR_CODE(SQLITE_CANTOPEN_DIRTYWAL),
         395                 :            :     DECLARE_ERROR_CODE(SQLITE_ERROR_SNAPSHOT),
         396                 :            : #endif
         397                 :            : #if SQLITE_VERSION_NUMBER >= 3031000
         398                 :            :     DECLARE_ERROR_CODE(SQLITE_CANTOPEN_SYMLINK),
         399                 :            :     DECLARE_ERROR_CODE(SQLITE_CONSTRAINT_PINNED),
         400                 :            :     DECLARE_ERROR_CODE(SQLITE_OK_SYMLINK),
         401                 :            : #endif
         402                 :            : #if SQLITE_VERSION_NUMBER >= 3032000
         403                 :            :     DECLARE_ERROR_CODE(SQLITE_BUSY_TIMEOUT),
         404                 :            :     DECLARE_ERROR_CODE(SQLITE_CORRUPT_INDEX),
         405                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_DATA),
         406                 :            : #endif
         407                 :            : #if SQLITE_VERSION_NUMBER >= 3034000
         408                 :            :     DECLARE_ERROR_CODE(SQLITE_IOERR_CORRUPTFS),
         409                 :            : #endif
         410                 :            : #undef DECLARE_ERROR_CODE
         411                 :            :     {NULL, 0},
         412                 :            : };
         413                 :            :
         414                 :            : static int
         415                 :          1 : add_error_constants(PyObject *module)
         416                 :            : {
         417         [ +  + ]:        106 :     for (int i = 0; error_codes[i].name != NULL; i++) {
         418                 :        105 :         const char *name = error_codes[i].name;
         419                 :        105 :         const long value = error_codes[i].value;
         420         [ -  + ]:        105 :         if (PyModule_AddIntConstant(module, name, value) < 0) {
         421                 :          0 :             return -1;
         422                 :            :         }
         423                 :            :     }
         424                 :          1 :     return 0;
         425                 :            : }
         426                 :            :
         427                 :            : const char *
         428                 :          0 : pysqlite_error_name(int rc)
         429                 :            : {
         430         [ #  # ]:          0 :     for (int i = 0; error_codes[i].name != NULL; i++) {
         431         [ #  # ]:          0 :         if (error_codes[i].value == rc) {
         432                 :          0 :             return error_codes[i].name;
         433                 :            :         }
         434                 :            :     }
         435                 :            :     // No error code matched.
         436                 :          0 :     return NULL;
         437                 :            : }
         438                 :            :
         439                 :            : static int
         440                 :          1 : add_integer_constants(PyObject *module) {
         441                 :            : #define ADD_INT(ival)                                           \
         442                 :            :     do {                                                        \
         443                 :            :         if (PyModule_AddIntConstant(module, #ival, ival) < 0) { \
         444                 :            :             return -1;                                          \
         445                 :            :         }                                                       \
         446                 :            :     } while (0);                                                \
         447                 :            :
         448         [ -  + ]:          1 :     ADD_INT(PARSE_DECLTYPES);
         449         [ -  + ]:          1 :     ADD_INT(PARSE_COLNAMES);
         450         [ -  + ]:          1 :     ADD_INT(SQLITE_DENY);
         451         [ -  + ]:          1 :     ADD_INT(SQLITE_IGNORE);
         452         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_INDEX);
         453         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_TABLE);
         454         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_TEMP_INDEX);
         455         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_TEMP_TABLE);
         456         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_TEMP_TRIGGER);
         457         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_TEMP_VIEW);
         458         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_TRIGGER);
         459         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_VIEW);
         460         [ -  + ]:          1 :     ADD_INT(SQLITE_DELETE);
         461         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_INDEX);
         462         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_TABLE);
         463         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_TEMP_INDEX);
         464         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_TEMP_TABLE);
         465         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_TEMP_TRIGGER);
         466         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_TEMP_VIEW);
         467         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_TRIGGER);
         468         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_VIEW);
         469         [ -  + ]:          1 :     ADD_INT(SQLITE_INSERT);
         470         [ -  + ]:          1 :     ADD_INT(SQLITE_PRAGMA);
         471         [ -  + ]:          1 :     ADD_INT(SQLITE_READ);
         472         [ -  + ]:          1 :     ADD_INT(SQLITE_SELECT);
         473         [ -  + ]:          1 :     ADD_INT(SQLITE_TRANSACTION);
         474         [ -  + ]:          1 :     ADD_INT(SQLITE_UPDATE);
         475         [ -  + ]:          1 :     ADD_INT(SQLITE_ATTACH);
         476         [ -  + ]:          1 :     ADD_INT(SQLITE_DETACH);
         477         [ -  + ]:          1 :     ADD_INT(SQLITE_ALTER_TABLE);
         478         [ -  + ]:          1 :     ADD_INT(SQLITE_REINDEX);
         479         [ -  + ]:          1 :     ADD_INT(SQLITE_ANALYZE);
         480         [ -  + ]:          1 :     ADD_INT(SQLITE_CREATE_VTABLE);
         481         [ -  + ]:          1 :     ADD_INT(SQLITE_DROP_VTABLE);
         482         [ -  + ]:          1 :     ADD_INT(SQLITE_FUNCTION);
         483         [ -  + ]:          1 :     ADD_INT(SQLITE_SAVEPOINT);
         484                 :            : #if SQLITE_VERSION_NUMBER >= 3008003
         485         [ -  + ]:          1 :     ADD_INT(SQLITE_RECURSIVE);
         486                 :            : #endif
         487                 :            :     // Run-time limit categories
         488         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_LENGTH);
         489         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_SQL_LENGTH);
         490         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_COLUMN);
         491         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_EXPR_DEPTH);
         492         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_COMPOUND_SELECT);
         493         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_VDBE_OP);
         494         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_FUNCTION_ARG);
         495         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_ATTACHED);
         496         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_LIKE_PATTERN_LENGTH);
         497         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_VARIABLE_NUMBER);
         498         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_TRIGGER_DEPTH);
         499                 :            : #if SQLITE_VERSION_NUMBER >= 3008007
         500         [ -  + ]:          1 :     ADD_INT(SQLITE_LIMIT_WORKER_THREADS);
         501                 :            : #endif
         502                 :            : #undef ADD_INT
         503                 :          1 :     return 0;
         504                 :            : }
         505                 :            :
         506                 :            : /* Convert SQLite default threading mode (as set by the compile-time constant
         507                 :            :  * SQLITE_THREADSAFE) to the corresponding DB-API 2.0 (PEP 249) threadsafety
         508                 :            :  * level. */
         509                 :            : static int
         510                 :          1 : get_threadsafety(pysqlite_state *state)
         511                 :            : {
         512                 :          1 :     int mode = sqlite3_threadsafe();
         513   [ -  +  -  - ]:          1 :     switch (mode) {
         514                 :          0 :     case 0:        // Single-thread mode; threads may not share the module.
         515                 :          0 :         return 0;
         516                 :          1 :     case 1:        // Serialized mode; threads may share the module,
         517                 :          1 :         return 3;  // connections, and cursors.
         518                 :          0 :     case 2:        // Multi-thread mode; threads may share the module, but not
         519                 :          0 :         return 1;  // connections.
         520                 :          0 :     default:
         521                 :          0 :         PyErr_Format(state->InterfaceError,
         522                 :            :                      "Unable to interpret SQLite threadsafety mode. Got %d, "
         523                 :            :                      "expected 0, 1, or 2", mode);
         524                 :          0 :         return -1;
         525                 :            :     }
         526                 :            : }
         527                 :            :
         528                 :            : static int
         529                 :          8 : module_traverse(PyObject *module, visitproc visit, void *arg)
         530                 :            : {
         531                 :          8 :     pysqlite_state *state = pysqlite_get_state(module);
         532                 :            :
         533                 :            :     // Exceptions
         534   [ +  -  -  + ]:          8 :     Py_VISIT(state->DataError);
         535   [ +  -  -  + ]:          8 :     Py_VISIT(state->DatabaseError);
         536   [ +  -  -  + ]:          8 :     Py_VISIT(state->Error);
         537   [ +  -  -  + ]:          8 :     Py_VISIT(state->IntegrityError);
         538   [ +  -  -  + ]:          8 :     Py_VISIT(state->InterfaceError);
         539   [ +  -  -  + ]:          8 :     Py_VISIT(state->InternalError);
         540   [ +  -  -  + ]:          8 :     Py_VISIT(state->NotSupportedError);
         541   [ +  -  -  + ]:          8 :     Py_VISIT(state->OperationalError);
         542   [ +  -  -  + ]:          8 :     Py_VISIT(state->ProgrammingError);
         543   [ +  -  -  + ]:          8 :     Py_VISIT(state->Warning);
         544                 :            :
         545                 :            :     // Types
         546   [ +  -  -  + ]:          8 :     Py_VISIT(state->BlobType);
         547   [ +  -  -  + ]:          8 :     Py_VISIT(state->ConnectionType);
         548   [ +  -  -  + ]:          8 :     Py_VISIT(state->CursorType);
         549   [ +  -  -  + ]:          8 :     Py_VISIT(state->PrepareProtocolType);
         550   [ +  -  -  + ]:          8 :     Py_VISIT(state->RowType);
         551   [ +  -  -  + ]:          8 :     Py_VISIT(state->StatementType);
         552                 :            :
         553                 :            :     // Misc
         554   [ +  -  -  + ]:          8 :     Py_VISIT(state->converters);
         555   [ +  -  -  + ]:          8 :     Py_VISIT(state->lru_cache);
         556   [ +  -  -  + ]:          8 :     Py_VISIT(state->psyco_adapters);
         557                 :            :
         558                 :          8 :     return 0;
         559                 :            : }
         560                 :            :
         561                 :            : static int
         562                 :          2 : module_clear(PyObject *module)
         563                 :            : {
         564                 :          2 :     pysqlite_state *state = pysqlite_get_state(module);
         565                 :            :
         566                 :            :     // Exceptions
         567         [ +  + ]:          2 :     Py_CLEAR(state->DataError);
         568         [ +  + ]:          2 :     Py_CLEAR(state->DatabaseError);
         569         [ +  + ]:          2 :     Py_CLEAR(state->Error);
         570         [ +  + ]:          2 :     Py_CLEAR(state->IntegrityError);
         571         [ +  + ]:          2 :     Py_CLEAR(state->InterfaceError);
         572         [ +  + ]:          2 :     Py_CLEAR(state->InternalError);
         573         [ +  + ]:          2 :     Py_CLEAR(state->NotSupportedError);
         574         [ +  + ]:          2 :     Py_CLEAR(state->OperationalError);
         575         [ +  + ]:          2 :     Py_CLEAR(state->ProgrammingError);
         576         [ +  + ]:          2 :     Py_CLEAR(state->Warning);
         577                 :            :
         578                 :            :     // Types
         579         [ +  + ]:          2 :     Py_CLEAR(state->BlobType);
         580         [ +  + ]:          2 :     Py_CLEAR(state->ConnectionType);
         581         [ +  + ]:          2 :     Py_CLEAR(state->CursorType);
         582         [ +  + ]:          2 :     Py_CLEAR(state->PrepareProtocolType);
         583         [ +  + ]:          2 :     Py_CLEAR(state->RowType);
         584         [ +  + ]:          2 :     Py_CLEAR(state->StatementType);
         585                 :            :
         586                 :            :     // Misc
         587         [ +  + ]:          2 :     Py_CLEAR(state->converters);
         588         [ +  + ]:          2 :     Py_CLEAR(state->lru_cache);
         589         [ +  + ]:          2 :     Py_CLEAR(state->psyco_adapters);
         590                 :            :
         591                 :            :     // Interned strings
         592         [ +  + ]:          2 :     Py_CLEAR(state->str___adapt__);
         593         [ +  + ]:          2 :     Py_CLEAR(state->str___conform__);
         594         [ +  + ]:          2 :     Py_CLEAR(state->str_executescript);
         595         [ +  + ]:          2 :     Py_CLEAR(state->str_finalize);
         596         [ +  + ]:          2 :     Py_CLEAR(state->str_inverse);
         597         [ +  + ]:          2 :     Py_CLEAR(state->str_step);
         598         [ +  + ]:          2 :     Py_CLEAR(state->str_upper);
         599         [ +  + ]:          2 :     Py_CLEAR(state->str_value);
         600                 :            :
         601                 :          2 :     return 0;
         602                 :            : }
         603                 :            :
         604                 :            : static void
         605                 :          1 : module_free(void *module)
         606                 :            : {
         607                 :          1 :     module_clear((PyObject *)module);
         608                 :          1 : }
         609                 :            :
         610                 :            : #define ADD_TYPE(module, type)                 \
         611                 :            : do {                                           \
         612                 :            :     if (PyModule_AddType(module, type) < 0) {  \
         613                 :            :         goto error;                            \
         614                 :            :     }                                          \
         615                 :            : } while (0)
         616                 :            :
         617                 :            : #define ADD_EXCEPTION(module, state, exc, base)                        \
         618                 :            : do {                                                                   \
         619                 :            :     state->exc = PyErr_NewException(MODULE_NAME "." #exc, base, NULL); \
         620                 :            :     if (state->exc == NULL) {                                          \
         621                 :            :         goto error;                                                    \
         622                 :            :     }                                                                  \
         623                 :            :     ADD_TYPE(module, (PyTypeObject *)state->exc);                      \
         624                 :            : } while (0)
         625                 :            :
         626                 :            : #define ADD_INTERNED(state, string)                      \
         627                 :            : do {                                                     \
         628                 :            :     PyObject *tmp = PyUnicode_InternFromString(#string); \
         629                 :            :     if (tmp == NULL) {                                   \
         630                 :            :         goto error;                                      \
         631                 :            :     }                                                    \
         632                 :            :     state->str_ ## string = tmp;                         \
         633                 :            : } while (0)
         634                 :            :
         635                 :            : static int
         636                 :          1 : module_exec(PyObject *module)
         637                 :            : {
         638         [ -  + ]:          1 :     if (sqlite3_libversion_number() < 3007015) {
         639                 :          0 :         PyErr_SetString(PyExc_ImportError, MODULE_NAME ": SQLite 3.7.15 or higher required");
         640                 :          0 :         return -1;
         641                 :            :     }
         642                 :            :
         643                 :          1 :     int rc = sqlite3_initialize();
         644         [ -  + ]:          1 :     if (rc != SQLITE_OK) {
         645                 :          0 :         PyErr_SetString(PyExc_ImportError, sqlite3_errstr(rc));
         646                 :          0 :         return -1;
         647                 :            :     }
         648                 :            :
         649   [ +  -  +  - ]:          2 :     if ((pysqlite_row_setup_types(module) < 0) ||
         650         [ +  - ]:          2 :         (pysqlite_cursor_setup_types(module) < 0) ||
         651         [ +  - ]:          2 :         (pysqlite_connection_setup_types(module) < 0) ||
         652         [ +  - ]:          2 :         (pysqlite_statement_setup_types(module) < 0) ||
         653         [ -  + ]:          2 :         (pysqlite_prepare_protocol_setup_types(module) < 0) ||
         654                 :          1 :         (pysqlite_blob_setup_types(module) < 0)
         655                 :            :        ) {
         656                 :          0 :         goto error;
         657                 :            :     }
         658                 :            :
         659                 :          1 :     pysqlite_state *state = pysqlite_get_state(module);
         660         [ -  + ]:          1 :     ADD_TYPE(module, state->BlobType);
         661         [ -  + ]:          1 :     ADD_TYPE(module, state->ConnectionType);
         662         [ -  + ]:          1 :     ADD_TYPE(module, state->CursorType);
         663         [ -  + ]:          1 :     ADD_TYPE(module, state->PrepareProtocolType);
         664         [ -  + ]:          1 :     ADD_TYPE(module, state->RowType);
         665                 :            :
         666                 :            :     /*** Create DB-API Exception hierarchy */
         667   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, Error, PyExc_Exception);
         668   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, Warning, PyExc_Exception);
         669                 :            :
         670                 :            :     /* Error subclasses */
         671   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, InterfaceError, state->Error);
         672   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, DatabaseError, state->Error);
         673                 :            :
         674                 :            :     /* DatabaseError subclasses */
         675   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, InternalError, state->DatabaseError);
         676   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, OperationalError, state->DatabaseError);
         677   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, ProgrammingError, state->DatabaseError);
         678   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, IntegrityError, state->DatabaseError);
         679   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, DataError, state->DatabaseError);
         680   [ -  +  -  + ]:          1 :     ADD_EXCEPTION(module, state, NotSupportedError, state->DatabaseError);
         681                 :            :
         682                 :            :     /* Add interned strings */
         683         [ -  + ]:          1 :     ADD_INTERNED(state, __adapt__);
         684         [ -  + ]:          1 :     ADD_INTERNED(state, __conform__);
         685         [ -  + ]:          1 :     ADD_INTERNED(state, executescript);
         686         [ -  + ]:          1 :     ADD_INTERNED(state, finalize);
         687         [ -  + ]:          1 :     ADD_INTERNED(state, inverse);
         688         [ -  + ]:          1 :     ADD_INTERNED(state, step);
         689         [ -  + ]:          1 :     ADD_INTERNED(state, upper);
         690         [ -  + ]:          1 :     ADD_INTERNED(state, value);
         691                 :            :
         692                 :            :     /* Set error constants */
         693         [ -  + ]:          1 :     if (add_error_constants(module) < 0) {
         694                 :          0 :         goto error;
         695                 :            :     }
         696                 :            :
         697                 :            :     /* Set integer constants */
         698         [ -  + ]:          1 :     if (add_integer_constants(module) < 0) {
         699                 :          0 :         goto error;
         700                 :            :     }
         701                 :            :
         702         [ -  + ]:          1 :     if (PyModule_AddStringConstant(module, "_deprecated_version", PYSQLITE_VERSION) < 0) {
         703                 :          0 :         goto error;
         704                 :            :     }
         705                 :            :
         706         [ -  + ]:          1 :     if (PyModule_AddStringConstant(module, "sqlite_version", sqlite3_libversion())) {
         707                 :          0 :         goto error;
         708                 :            :     }
         709                 :            :
         710         [ -  + ]:          1 :     if (PyModule_AddIntMacro(module, LEGACY_TRANSACTION_CONTROL) < 0) {
         711                 :          0 :         goto error;
         712                 :            :     }
         713                 :            :
         714                 :          1 :     int threadsafety = get_threadsafety(state);
         715         [ -  + ]:          1 :     if (threadsafety < 0) {
         716                 :          0 :         goto error;
         717                 :            :     }
         718         [ -  + ]:          1 :     if (PyModule_AddIntConstant(module, "threadsafety", threadsafety) < 0) {
         719                 :          0 :         goto error;
         720                 :            :     }
         721                 :            :
         722                 :            :     /* initialize microprotocols layer */
         723         [ -  + ]:          1 :     if (pysqlite_microprotocols_init(module) < 0) {
         724                 :          0 :         goto error;
         725                 :            :     }
         726                 :            :
         727                 :            :     /* initialize the default converters */
         728         [ -  + ]:          1 :     if (converters_init(module) < 0) {
         729                 :          0 :         goto error;
         730                 :            :     }
         731                 :            :
         732         [ -  + ]:          1 :     if (load_functools_lru_cache(module) < 0) {
         733                 :          0 :         goto error;
         734                 :            :     }
         735                 :            :
         736                 :          1 :     return 0;
         737                 :            :
         738                 :          0 : error:
         739                 :          0 :     sqlite3_shutdown();
         740                 :          0 :     return -1;
         741                 :            : }
         742                 :            :
         743                 :            : static struct PyModuleDef_Slot module_slots[] = {
         744                 :            :     {Py_mod_exec, module_exec},
         745                 :            :     {0, NULL},
         746                 :            : };
         747                 :            :
         748                 :            : struct PyModuleDef _sqlite3module = {
         749                 :            :     .m_base = PyModuleDef_HEAD_INIT,
         750                 :            :     .m_name = "_sqlite3",
         751                 :            :     .m_size = sizeof(pysqlite_state),
         752                 :            :     .m_methods = module_methods,
         753                 :            :     .m_slots = module_slots,
         754                 :            :     .m_traverse = module_traverse,
         755                 :            :     .m_clear = module_clear,
         756                 :            :     .m_free = module_free,
         757                 :            : };
         758                 :            :
         759                 :            : PyMODINIT_FUNC
         760                 :          1 : PyInit__sqlite3(void)
         761                 :            : {
         762                 :          1 :     return PyModuleDef_Init(&_sqlite3module);
         763                 :            : }

Generated by: LCOV version 1.14