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