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