/Users/erlendaasland/src/cpython.git/Modules/_sqlite/module.c
Line | Count | Source (jump to first uncovered line) |
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 | 505 | #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 | | 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 | 498 | { |
71 | 498 | if (isolation_level == NULL) { |
72 | 477 | isolation_level = PyUnicode_FromString(""); |
73 | 477 | if (isolation_level == NULL) { |
74 | 0 | return NULL; |
75 | 0 | } |
76 | 477 | } |
77 | 21 | else { |
78 | 21 | Py_INCREF(isolation_level); |
79 | 21 | } |
80 | 498 | PyObject *res = PyObject_CallFunction(factory, "OdiOiOii", database, |
81 | 498 | timeout, detect_types, |
82 | 498 | isolation_level, check_same_thread, |
83 | 498 | factory, cached_statements, uri); |
84 | 498 | Py_DECREF(isolation_level); |
85 | 498 | return res; |
86 | 498 | } |
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 | | pysqlite_complete_statement_impl(PyObject *module, const char *statement) |
98 | | /*[clinic end generated code: output=e55f1ff1952df558 input=ac45d257375bb828]*/ |
99 | 2 | { |
100 | 2 | if (sqlite3_complete(statement)) { |
101 | 1 | return Py_NewRef(Py_True); |
102 | 1 | } else { |
103 | 1 | return Py_NewRef(Py_False); |
104 | 1 | } |
105 | 2 | } |
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 | | pysqlite_register_adapter_impl(PyObject *module, PyTypeObject *type, |
119 | | PyObject *caster) |
120 | | /*[clinic end generated code: output=a287e8db18e8af23 input=29a5e0f213030242]*/ |
121 | 11 | { |
122 | 11 | 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 | 11 | if (type == &PyLong_Type || type == &PyFloat_Type |
127 | 11 | || type == &PyUnicode_Type || type == &PyByteArray_Type) { |
128 | 8 | pysqlite_state *state = pysqlite_get_state(module); |
129 | 8 | state->BaseTypeAdapted = 1; |
130 | 8 | } |
131 | | |
132 | 11 | pysqlite_state *state = pysqlite_get_state(module); |
133 | 11 | PyObject *protocol = (PyObject *)state->PrepareProtocolType; |
134 | 11 | rc = pysqlite_microprotocols_add(state, type, protocol, caster); |
135 | 11 | if (rc == -1) { |
136 | 1 | return NULL; |
137 | 1 | } |
138 | | |
139 | 11 | Py_RETURN_NONE; |
140 | 11 | } |
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 | | pysqlite_register_converter_impl(PyObject *module, PyObject *orig_name, |
154 | | PyObject *callable) |
155 | | /*[clinic end generated code: output=a2f2bfeed7230062 input=159a444971b40378]*/ |
156 | 3 | { |
157 | 3 | PyObject* name = NULL; |
158 | 3 | PyObject* retval = NULL; |
159 | | |
160 | | /* convert the name to upper case */ |
161 | 3 | pysqlite_state *state = pysqlite_get_state(module); |
162 | 3 | name = PyObject_CallMethodNoArgs(orig_name, state->str_upper); |
163 | 3 | if (!name) { |
164 | 0 | goto error; |
165 | 0 | } |
166 | | |
167 | 3 | if (PyDict_SetItem(state->converters, name, callable) != 0) { |
168 | 0 | goto error; |
169 | 0 | } |
170 | | |
171 | 3 | retval = Py_NewRef(Py_None); |
172 | 3 | error: |
173 | 3 | Py_XDECREF(name); |
174 | 3 | return retval; |
175 | 3 | } |
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 | | pysqlite_enable_callback_trace_impl(PyObject *module, int enable) |
188 | | /*[clinic end generated code: output=4ff1d051c698f194 input=cb79d3581eb77c40]*/ |
189 | 40 | { |
190 | 40 | pysqlite_state *state = pysqlite_get_state(module); |
191 | 40 | state->enable_callback_tracebacks = enable; |
192 | | |
193 | 40 | Py_RETURN_NONE; |
194 | 40 | } |
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 | | pysqlite_adapt_impl(PyObject *module, PyObject *obj, PyObject *proto, |
209 | | PyObject *alt) |
210 | | /*[clinic end generated code: output=0c3927c5fcd23dd9 input=a53dc9993e81e15f]*/ |
211 | 7 | { |
212 | 7 | pysqlite_state *state = pysqlite_get_state(module); |
213 | 7 | return pysqlite_microprotocols_adapt(state, obj, proto, alt); |
214 | 7 | } |
215 | | |
216 | | static int converters_init(PyObject* module) |
217 | 1 | { |
218 | 1 | pysqlite_state *state = pysqlite_get_state(module); |
219 | 1 | state->converters = PyDict_New(); |
220 | 1 | if (state->converters == NULL) { |
221 | 0 | return -1; |
222 | 0 | } |
223 | | |
224 | 1 | return PyModule_AddObjectRef(module, "converters", state->converters); |
225 | 1 | } |
226 | | |
227 | | static int |
228 | | load_functools_lru_cache(PyObject *module) |
229 | 1 | { |
230 | 1 | pysqlite_state *state = pysqlite_get_state(module); |
231 | 1 | state->lru_cache = _PyImport_GetModuleAttrString("functools", "lru_cache"); |
232 | 1 | if (state->lru_cache == NULL) { |
233 | 0 | return -1; |
234 | 0 | } |
235 | 1 | return 0; |
236 | 1 | } |
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 | | add_error_constants(PyObject *module) |
418 | 1 | { |
419 | 106 | for (int i = 0; error_codes[i].name != NULL; i++) { |
420 | 105 | const char *name = error_codes[i].name; |
421 | 105 | const long value = error_codes[i].value; |
422 | 105 | if (PyModule_AddIntConstant(module, name, value) < 0) { |
423 | 0 | return -1; |
424 | 0 | } |
425 | 105 | } |
426 | 1 | return 0; |
427 | 1 | } |
428 | | |
429 | | const char * |
430 | | pysqlite_error_name(int rc) |
431 | 97 | { |
432 | 1.76k | for (int i = 0; error_codes[i].name != NULL; i++) { |
433 | 1.76k | if (error_codes[i].value == rc) { |
434 | 97 | return error_codes[i].name; |
435 | 97 | } |
436 | 1.76k | } |
437 | | // No error code matched. |
438 | 0 | return NULL; |
439 | 97 | } |
440 | | |
441 | | static int |
442 | 1 | add_integer_constants(PyObject *module) { |
443 | 1 | #define ADD_INT(ival) \ |
444 | 49 | do { \ |
445 | 49 | if (PyModule_AddIntConstant(module, #ival, ival) < 0) { \ |
446 | 0 | return -1; \ |
447 | 0 | } \ |
448 | 49 | } while (0); \ |
449 | 1 | |
450 | 1 | ADD_INT(PARSE_DECLTYPES); |
451 | 1 | ADD_INT(PARSE_COLNAMES); |
452 | 1 | ADD_INT(SQLITE_DENY); |
453 | 1 | ADD_INT(SQLITE_IGNORE); |
454 | 1 | ADD_INT(SQLITE_CREATE_INDEX); |
455 | 1 | ADD_INT(SQLITE_CREATE_TABLE); |
456 | 1 | ADD_INT(SQLITE_CREATE_TEMP_INDEX); |
457 | 1 | ADD_INT(SQLITE_CREATE_TEMP_TABLE); |
458 | 1 | ADD_INT(SQLITE_CREATE_TEMP_TRIGGER); |
459 | 1 | ADD_INT(SQLITE_CREATE_TEMP_VIEW); |
460 | 1 | ADD_INT(SQLITE_CREATE_TRIGGER); |
461 | 1 | ADD_INT(SQLITE_CREATE_VIEW); |
462 | 1 | ADD_INT(SQLITE_DELETE); |
463 | 1 | ADD_INT(SQLITE_DROP_INDEX); |
464 | 1 | ADD_INT(SQLITE_DROP_TABLE); |
465 | 1 | ADD_INT(SQLITE_DROP_TEMP_INDEX); |
466 | 1 | ADD_INT(SQLITE_DROP_TEMP_TABLE); |
467 | 1 | ADD_INT(SQLITE_DROP_TEMP_TRIGGER); |
468 | 1 | ADD_INT(SQLITE_DROP_TEMP_VIEW); |
469 | 1 | ADD_INT(SQLITE_DROP_TRIGGER); |
470 | 1 | ADD_INT(SQLITE_DROP_VIEW); |
471 | 1 | ADD_INT(SQLITE_INSERT); |
472 | 1 | ADD_INT(SQLITE_PRAGMA); |
473 | 1 | ADD_INT(SQLITE_READ); |
474 | 1 | ADD_INT(SQLITE_SELECT); |
475 | 1 | ADD_INT(SQLITE_TRANSACTION); |
476 | 1 | ADD_INT(SQLITE_UPDATE); |
477 | 1 | ADD_INT(SQLITE_ATTACH); |
478 | 1 | ADD_INT(SQLITE_DETACH); |
479 | 1 | ADD_INT(SQLITE_ALTER_TABLE); |
480 | 1 | ADD_INT(SQLITE_REINDEX); |
481 | 1 | ADD_INT(SQLITE_ANALYZE); |
482 | 1 | ADD_INT(SQLITE_CREATE_VTABLE); |
483 | 1 | ADD_INT(SQLITE_DROP_VTABLE); |
484 | 1 | ADD_INT(SQLITE_FUNCTION); |
485 | 1 | ADD_INT(SQLITE_SAVEPOINT); |
486 | 1 | #if SQLITE_VERSION_NUMBER >= 3008003 |
487 | 1 | ADD_INT(SQLITE_RECURSIVE); |
488 | 1 | #endif |
489 | | // Run-time limit categories |
490 | 1 | ADD_INT(SQLITE_LIMIT_LENGTH); |
491 | 1 | ADD_INT(SQLITE_LIMIT_SQL_LENGTH); |
492 | 1 | ADD_INT(SQLITE_LIMIT_COLUMN); |
493 | 1 | ADD_INT(SQLITE_LIMIT_EXPR_DEPTH); |
494 | 1 | ADD_INT(SQLITE_LIMIT_COMPOUND_SELECT); |
495 | 1 | ADD_INT(SQLITE_LIMIT_VDBE_OP); |
496 | 1 | ADD_INT(SQLITE_LIMIT_FUNCTION_ARG); |
497 | 1 | ADD_INT(SQLITE_LIMIT_ATTACHED); |
498 | 1 | ADD_INT(SQLITE_LIMIT_LIKE_PATTERN_LENGTH); |
499 | 1 | ADD_INT(SQLITE_LIMIT_VARIABLE_NUMBER); |
500 | 1 | ADD_INT(SQLITE_LIMIT_TRIGGER_DEPTH); |
501 | 1 | #if SQLITE_VERSION_NUMBER >= 3008007 |
502 | 1 | ADD_INT(SQLITE_LIMIT_WORKER_THREADS); |
503 | 1 | #endif |
504 | 1 | #undef ADD_INT |
505 | 1 | return 0; |
506 | 1 | } |
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 | | get_threadsafety(pysqlite_state *state) |
513 | 1 | { |
514 | 1 | int mode = sqlite3_threadsafe(); |
515 | 1 | switch (mode) { |
516 | 0 | case 0: // Single-thread mode; threads may not share the module. |
517 | 0 | return 0; |
518 | 1 | case 1: // Serialized mode; threads may share the module, |
519 | 1 | 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 | 0 | "Unable to interpret SQLite threadsafety mode. Got %d, " |
525 | 0 | "expected 0, 1, or 2", mode); |
526 | 0 | return -1; |
527 | 1 | } |
528 | 1 | } |
529 | | |
530 | | static int |
531 | | module_traverse(PyObject *module, visitproc visit, void *arg) |
532 | 38 | { |
533 | 38 | pysqlite_state *state = pysqlite_get_state(module); |
534 | | |
535 | | // Exceptions |
536 | 38 | Py_VISIT(state->DataError); |
537 | 38 | Py_VISIT(state->DatabaseError); |
538 | 38 | Py_VISIT(state->Error); |
539 | 38 | Py_VISIT(state->IntegrityError); |
540 | 38 | Py_VISIT(state->InterfaceError); |
541 | 38 | Py_VISIT(state->InternalError); |
542 | 38 | Py_VISIT(state->NotSupportedError); |
543 | 38 | Py_VISIT(state->OperationalError); |
544 | 38 | Py_VISIT(state->ProgrammingError); |
545 | 38 | Py_VISIT(state->Warning); |
546 | | |
547 | | // Types |
548 | 38 | Py_VISIT(state->BlobType); |
549 | 38 | Py_VISIT(state->ConnectionType); |
550 | 38 | Py_VISIT(state->CursorType); |
551 | 38 | Py_VISIT(state->PrepareProtocolType); |
552 | 38 | Py_VISIT(state->RowType); |
553 | 38 | Py_VISIT(state->StatementType); |
554 | | |
555 | | // Misc |
556 | 38 | Py_VISIT(state->converters); |
557 | 38 | Py_VISIT(state->lru_cache); |
558 | 38 | Py_VISIT(state->psyco_adapters); |
559 | | |
560 | 38 | return 0; |
561 | 38 | } |
562 | | |
563 | | static int |
564 | | module_clear(PyObject *module) |
565 | 2 | { |
566 | 2 | pysqlite_state *state = pysqlite_get_state(module); |
567 | | |
568 | | // Exceptions |
569 | 2 | Py_CLEAR(state->DataError); |
570 | 2 | Py_CLEAR(state->DatabaseError); |
571 | 2 | Py_CLEAR(state->Error); |
572 | 2 | Py_CLEAR(state->IntegrityError); |
573 | 2 | Py_CLEAR(state->InterfaceError); |
574 | 2 | Py_CLEAR(state->InternalError); |
575 | 2 | Py_CLEAR(state->NotSupportedError); |
576 | 2 | Py_CLEAR(state->OperationalError); |
577 | 2 | Py_CLEAR(state->ProgrammingError); |
578 | 2 | Py_CLEAR(state->Warning); |
579 | | |
580 | | // Types |
581 | 2 | Py_CLEAR(state->BlobType); |
582 | 2 | Py_CLEAR(state->ConnectionType); |
583 | 2 | Py_CLEAR(state->CursorType); |
584 | 2 | Py_CLEAR(state->PrepareProtocolType); |
585 | 2 | Py_CLEAR(state->RowType); |
586 | 2 | Py_CLEAR(state->StatementType); |
587 | | |
588 | | // Misc |
589 | 2 | Py_CLEAR(state->converters); |
590 | 2 | Py_CLEAR(state->lru_cache); |
591 | 2 | Py_CLEAR(state->psyco_adapters); |
592 | | |
593 | | // Interned strings |
594 | 2 | Py_CLEAR(state->str___adapt__); |
595 | 2 | Py_CLEAR(state->str___conform__); |
596 | 2 | Py_CLEAR(state->str_executescript); |
597 | 2 | Py_CLEAR(state->str_finalize); |
598 | 2 | Py_CLEAR(state->str_inverse); |
599 | 2 | Py_CLEAR(state->str_step); |
600 | 2 | Py_CLEAR(state->str_upper); |
601 | 2 | Py_CLEAR(state->str_value); |
602 | | |
603 | 2 | return 0; |
604 | 2 | } |
605 | | |
606 | | static void |
607 | | module_free(void *module) |
608 | 1 | { |
609 | 1 | module_clear((PyObject *)module); |
610 | 1 | } |
611 | | |
612 | 15 | #define ADD_TYPE(module, type) \ |
613 | 15 | do { \ |
614 | 15 | if (PyModule_AddType(module, type) < 0) { \ |
615 | 0 | goto error; \ |
616 | 0 | } \ |
617 | 15 | } while (0) |
618 | | |
619 | 10 | #define ADD_EXCEPTION(module, state, exc, base) \ |
620 | 10 | do { \ |
621 | 10 | state->exc = PyErr_NewException(MODULE_NAME "." #exc, base, NULL); \ |
622 | 10 | if (state->exc == NULL) { \ |
623 | 0 | goto error; \ |
624 | 0 | } \ |
625 | 10 | ADD_TYPE(module, (PyTypeObject *)state->exc); \ |
626 | 10 | } while (0) |
627 | | |
628 | 8 | #define ADD_INTERNED(state, string) \ |
629 | 8 | do { \ |
630 | 8 | PyObject *tmp = PyUnicode_InternFromString(#string); \ |
631 | 8 | if (tmp == NULL) { \ |
632 | 0 | goto error; \ |
633 | 0 | } \ |
634 | 8 | state->str_ ## string = tmp; \ |
635 | 8 | } while (0) |
636 | | |
637 | | static int |
638 | | module_exec(PyObject *module) |
639 | 1 | { |
640 | 1 | 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 | 0 | } |
644 | | |
645 | 1 | int rc = sqlite3_initialize(); |
646 | 1 | if (rc != SQLITE_OK) { |
647 | 0 | PyErr_SetString(PyExc_ImportError, sqlite3_errstr(rc)); |
648 | 0 | return -1; |
649 | 0 | } |
650 | | |
651 | 1 | if ((pysqlite_row_setup_types(module) < 0) || |
652 | 1 | (pysqlite_cursor_setup_types(module) < 0) || |
653 | 1 | (pysqlite_connection_setup_types(module) < 0) || |
654 | 1 | (pysqlite_statement_setup_types(module) < 0) || |
655 | 1 | (pysqlite_prepare_protocol_setup_types(module) < 0) || |
656 | 1 | (pysqlite_blob_setup_types(module) < 0) |
657 | 1 | ) { |
658 | 0 | goto error; |
659 | 0 | } |
660 | | |
661 | 1 | pysqlite_state *state = pysqlite_get_state(module); |
662 | 1 | ADD_TYPE(module, state->BlobType); |
663 | 1 | ADD_TYPE(module, state->ConnectionType); |
664 | 1 | ADD_TYPE(module, state->CursorType); |
665 | 1 | ADD_TYPE(module, state->PrepareProtocolType); |
666 | 1 | ADD_TYPE(module, state->RowType); |
667 | | |
668 | | /*** Create DB-API Exception hierarchy */ |
669 | 1 | ADD_EXCEPTION(module, state, Error, PyExc_Exception); |
670 | 1 | ADD_EXCEPTION(module, state, Warning, PyExc_Exception); |
671 | | |
672 | | /* Error subclasses */ |
673 | 1 | ADD_EXCEPTION(module, state, InterfaceError, state->Error); |
674 | 1 | ADD_EXCEPTION(module, state, DatabaseError, state->Error); |
675 | | |
676 | | /* DatabaseError subclasses */ |
677 | 1 | ADD_EXCEPTION(module, state, InternalError, state->DatabaseError); |
678 | 1 | ADD_EXCEPTION(module, state, OperationalError, state->DatabaseError); |
679 | 1 | ADD_EXCEPTION(module, state, ProgrammingError, state->DatabaseError); |
680 | 1 | ADD_EXCEPTION(module, state, IntegrityError, state->DatabaseError); |
681 | 1 | ADD_EXCEPTION(module, state, DataError, state->DatabaseError); |
682 | 1 | ADD_EXCEPTION(module, state, NotSupportedError, state->DatabaseError); |
683 | | |
684 | | /* Add interned strings */ |
685 | 1 | ADD_INTERNED(state, __adapt__); |
686 | 1 | ADD_INTERNED(state, __conform__); |
687 | 1 | ADD_INTERNED(state, executescript); |
688 | 1 | ADD_INTERNED(state, finalize); |
689 | 1 | ADD_INTERNED(state, inverse); |
690 | 1 | ADD_INTERNED(state, step); |
691 | 1 | ADD_INTERNED(state, upper); |
692 | 1 | ADD_INTERNED(state, value); |
693 | | |
694 | | /* Set error constants */ |
695 | 1 | if (add_error_constants(module) < 0) { |
696 | 0 | goto error; |
697 | 0 | } |
698 | | |
699 | | /* Set integer constants */ |
700 | 1 | if (add_integer_constants(module) < 0) { |
701 | 0 | goto error; |
702 | 0 | } |
703 | | |
704 | 1 | if (PyModule_AddStringConstant(module, "_deprecated_version", PYSQLITE_VERSION) < 0) { |
705 | 0 | goto error; |
706 | 0 | } |
707 | | |
708 | 1 | if (PyModule_AddStringConstant(module, "sqlite_version", sqlite3_libversion())) { |
709 | 0 | goto error; |
710 | 0 | } |
711 | | |
712 | 1 | int threadsafety = get_threadsafety(state); |
713 | 1 | if (threadsafety < 0) { |
714 | 0 | goto error; |
715 | 0 | } |
716 | 1 | if (PyModule_AddIntConstant(module, "threadsafety", threadsafety) < 0) { |
717 | 0 | goto error; |
718 | 0 | } |
719 | | |
720 | | /* initialize microprotocols layer */ |
721 | 1 | if (pysqlite_microprotocols_init(module) < 0) { |
722 | 0 | goto error; |
723 | 0 | } |
724 | | |
725 | | /* initialize the default converters */ |
726 | 1 | if (converters_init(module) < 0) { |
727 | 0 | goto error; |
728 | 0 | } |
729 | | |
730 | 1 | if (load_functools_lru_cache(module) < 0) { |
731 | 0 | goto error; |
732 | 0 | } |
733 | | |
734 | 1 | return 0; |
735 | | |
736 | 0 | error: |
737 | 0 | sqlite3_shutdown(); |
738 | 0 | return -1; |
739 | 1 | } |
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 | | PyInit__sqlite3(void) |
759 | 1 | { |
760 | 1 | return PyModuleDef_Init(&_sqlite3module); |
761 | 1 | } |