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