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