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