Coverage Report

Created: 2022-07-08 00:21

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