Debian Codegraph @

Modules/_sqlite/module.c

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