Branch data Line data Source code
1 : : /* connection.c - the connection type
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 "module.h"
25 : : #include "structmember.h" // PyMemberDef
26 : : #include "connection.h"
27 : : #include "statement.h"
28 : : #include "cursor.h"
29 : : #include "blob.h"
30 : : #include "prepare_protocol.h"
31 : : #include "util.h"
32 : :
33 : : #if SQLITE_VERSION_NUMBER >= 3014000
34 : : #define HAVE_TRACE_V2
35 : : #endif
36 : :
37 : : #if SQLITE_VERSION_NUMBER >= 3025000
38 : : #define HAVE_WINDOW_FUNCTIONS
39 : : #endif
40 : :
41 : : static const char *
42 : 536 : get_isolation_level(const char *level)
43 : : {
44 : : assert(level != NULL);
45 : : static const char *const allowed_levels[] = {
46 : : "",
47 : : "DEFERRED",
48 : : "IMMEDIATE",
49 : : "EXCLUSIVE",
50 : : NULL
51 : : };
52 [ + + ]: 658 : for (int i = 0; allowed_levels[i] != NULL; i++) {
53 : 640 : const char *candidate = allowed_levels[i];
54 [ + + ]: 640 : if (sqlite3_stricmp(level, candidate) == 0) {
55 : 518 : return candidate;
56 : : }
57 : : }
58 : 18 : PyErr_SetString(PyExc_ValueError,
59 : : "isolation_level string must be '', 'DEFERRED', "
60 : : "'IMMEDIATE', or 'EXCLUSIVE'");
61 : 18 : return NULL;
62 : : }
63 : :
64 : : static int
65 : 544 : isolation_level_converter(PyObject *str_or_none, const char **result)
66 : : {
67 [ + + ]: 544 : if (Py_IsNone(str_or_none)) {
68 : 4 : *result = NULL;
69 : : }
70 [ + + ]: 540 : else if (PyUnicode_Check(str_or_none)) {
71 : : Py_ssize_t sz;
72 : 537 : const char *str = PyUnicode_AsUTF8AndSize(str_or_none, &sz);
73 [ - + ]: 537 : if (str == NULL) {
74 : 19 : return 0;
75 : : }
76 [ + + ]: 537 : if (strlen(str) != (size_t)sz) {
77 : 1 : PyErr_SetString(PyExc_ValueError, "embedded null character");
78 : 1 : return 0;
79 : : }
80 : :
81 : 536 : const char *level = get_isolation_level(str);
82 [ + + ]: 536 : if (level == NULL) {
83 : 18 : return 0;
84 : : }
85 : 518 : *result = level;
86 : : }
87 : : else {
88 : 3 : PyErr_SetString(PyExc_TypeError,
89 : : "isolation_level must be str or None");
90 : 3 : return 0;
91 : : }
92 : 522 : return 1;
93 : : }
94 : :
95 : : #define clinic_state() (pysqlite_get_state_by_type(Py_TYPE(self)))
96 : : #include "clinic/connection.c.h"
97 : : #undef clinic_state
98 : :
99 : : /*[clinic input]
100 : : module _sqlite3
101 : : class _sqlite3.Connection "pysqlite_Connection *" "clinic_state()->ConnectionType"
102 : : [clinic start generated code]*/
103 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=67369db2faf80891]*/
104 : :
105 : : static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self);
106 : : static void free_callback_context(callback_context *ctx);
107 : : static void set_callback_context(callback_context **ctx_pp,
108 : : callback_context *ctx);
109 : : static void connection_close(pysqlite_Connection *self);
110 : : PyObject *_pysqlite_query_execute(pysqlite_Cursor *, int, PyObject *, PyObject *);
111 : :
112 : : static PyObject *
113 : 491 : new_statement_cache(pysqlite_Connection *self, pysqlite_state *state,
114 : : int maxsize)
115 : : {
116 : 491 : PyObject *args[] = { NULL, PyLong_FromLong(maxsize), };
117 [ - + ]: 491 : if (args[1] == NULL) {
118 : 0 : return NULL;
119 : : }
120 : 491 : PyObject *lru_cache = state->lru_cache;
121 : 491 : size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
122 : 491 : PyObject *inner = PyObject_Vectorcall(lru_cache, args + 1, nargsf, NULL);
123 : 491 : Py_DECREF(args[1]);
124 [ - + ]: 491 : if (inner == NULL) {
125 : 0 : return NULL;
126 : : }
127 : :
128 : 491 : args[1] = (PyObject *)self; // Borrowed ref.
129 : 491 : nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
130 : 491 : PyObject *res = PyObject_Vectorcall(inner, args + 1, nargsf, NULL);
131 : 491 : Py_DECREF(inner);
132 : 491 : return res;
133 : : }
134 : :
135 : : /*[python input]
136 : : class IsolationLevel_converter(CConverter):
137 : : type = "const char *"
138 : : converter = "isolation_level_converter"
139 : :
140 : : [python start generated code]*/
141 : : /*[python end generated code: output=da39a3ee5e6b4b0d input=cbcfe85b253061c2]*/
142 : :
143 : : /*[clinic input]
144 : : _sqlite3.Connection.__init__ as pysqlite_connection_init
145 : :
146 : : database: object
147 : : timeout: double = 5.0
148 : : detect_types: int = 0
149 : : isolation_level: IsolationLevel = ""
150 : : check_same_thread: bool(accept={int}) = True
151 : : factory: object(c_default='(PyObject*)clinic_state()->ConnectionType') = ConnectionType
152 : : cached_statements as cache_size: int = 128
153 : : uri: bool = False
154 : : [clinic start generated code]*/
155 : :
156 : : static int
157 : 495 : pysqlite_connection_init_impl(pysqlite_Connection *self, PyObject *database,
158 : : double timeout, int detect_types,
159 : : const char *isolation_level,
160 : : int check_same_thread, PyObject *factory,
161 : : int cache_size, int uri)
162 : : /*[clinic end generated code: output=839eb2fee4293bda input=b8ce63dc6f70a383]*/
163 : : {
164 [ - + ]: 495 : if (PySys_Audit("sqlite3.connect", "O", database) < 0) {
165 : 0 : return -1;
166 : : }
167 : :
168 : : PyObject *bytes;
169 [ - + ]: 495 : if (!PyUnicode_FSConverter(database, &bytes)) {
170 : 0 : return -1;
171 : : }
172 : :
173 [ + + ]: 495 : if (self->initialized) {
174 : 2 : PyTypeObject *tp = Py_TYPE(self);
175 : 2 : tp->tp_clear((PyObject *)self);
176 : 2 : connection_close(self);
177 : 2 : self->initialized = 0;
178 : : }
179 : :
180 : : // Create and configure SQLite database object.
181 : : sqlite3 *db;
182 : : int rc;
183 : 495 : Py_BEGIN_ALLOW_THREADS
184 [ + + ]: 495 : rc = sqlite3_open_v2(PyBytes_AS_STRING(bytes), &db,
185 : : SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
186 : : (uri ? SQLITE_OPEN_URI : 0), NULL);
187 [ + + ]: 495 : if (rc == SQLITE_OK) {
188 : 491 : (void)sqlite3_busy_timeout(db, (int)(timeout*1000));
189 : : }
190 : 495 : Py_END_ALLOW_THREADS
191 : :
192 : 495 : Py_DECREF(bytes);
193 [ - + - - ]: 495 : if (db == NULL && rc == SQLITE_NOMEM) {
194 : : PyErr_NoMemory();
195 : 0 : return -1;
196 : : }
197 : :
198 : 495 : pysqlite_state *state = pysqlite_get_state_by_type(Py_TYPE(self));
199 [ + + ]: 495 : if (rc != SQLITE_OK) {
200 : 4 : _pysqlite_seterror(state, db);
201 : 4 : goto error;
202 : : }
203 : :
204 : : // Create LRU statement cache; returns a new reference.
205 : 491 : PyObject *statement_cache = new_statement_cache(self, state, cache_size);
206 [ - + ]: 491 : if (statement_cache == NULL) {
207 : 0 : goto error;
208 : : }
209 : :
210 : : /* Create lists of weak references to cursors and blobs */
211 : 491 : PyObject *cursors = PyList_New(0);
212 [ - + ]: 491 : if (cursors == NULL) {
213 : 0 : Py_DECREF(statement_cache);
214 : 0 : goto error;
215 : : }
216 : :
217 : 491 : PyObject *blobs = PyList_New(0);
218 [ - + ]: 491 : if (blobs == NULL) {
219 : 0 : Py_DECREF(statement_cache);
220 : 0 : Py_DECREF(cursors);
221 : 0 : goto error;
222 : : }
223 : :
224 : : // Init connection state members.
225 : 491 : self->db = db;
226 : 491 : self->state = state;
227 : 491 : self->detect_types = detect_types;
228 : 491 : self->isolation_level = isolation_level;
229 : 491 : self->check_same_thread = check_same_thread;
230 : 491 : self->thread_ident = PyThread_get_thread_ident();
231 : 491 : self->statement_cache = statement_cache;
232 : 491 : self->cursors = cursors;
233 : 491 : self->blobs = blobs;
234 : 491 : self->created_cursors = 0;
235 : 491 : self->row_factory = Py_NewRef(Py_None);
236 : 491 : self->text_factory = Py_NewRef(&PyUnicode_Type);
237 : 491 : self->trace_ctx = NULL;
238 : 491 : self->progress_ctx = NULL;
239 : 491 : self->authorizer_ctx = NULL;
240 : :
241 : : // Borrowed refs
242 : 491 : self->Warning = state->Warning;
243 : 491 : self->Error = state->Error;
244 : 491 : self->InterfaceError = state->InterfaceError;
245 : 491 : self->DatabaseError = state->DatabaseError;
246 : 491 : self->DataError = state->DataError;
247 : 491 : self->OperationalError = state->OperationalError;
248 : 491 : self->IntegrityError = state->IntegrityError;
249 : 491 : self->InternalError = state->InternalError;
250 : 491 : self->ProgrammingError = state->ProgrammingError;
251 : 491 : self->NotSupportedError = state->NotSupportedError;
252 : :
253 [ - + ]: 491 : if (PySys_Audit("sqlite3.connect/handle", "O", self) < 0) {
254 : 0 : return -1; // Don't goto error; at this point, dealloc will clean up.
255 : : }
256 : :
257 : 491 : self->initialized = 1;
258 : 491 : return 0;
259 : :
260 : 4 : error:
261 : : // There are no statements or other SQLite objects attached to the
262 : : // database, so sqlite3_close() should always return SQLITE_OK.
263 : 4 : rc = sqlite3_close(db);
264 : : assert(rc == SQLITE_OK);
265 : 4 : return -1;
266 : : }
267 : :
268 : : #define VISIT_CALLBACK_CONTEXT(ctx) \
269 : : do { \
270 : : if (ctx) { \
271 : : Py_VISIT(ctx->callable); \
272 : : Py_VISIT(ctx->module); \
273 : : } \
274 : : } while (0)
275 : :
276 : : static int
277 : 256 : connection_traverse(pysqlite_Connection *self, visitproc visit, void *arg)
278 : : {
279 [ + - - + ]: 256 : Py_VISIT(Py_TYPE(self));
280 [ + + - + ]: 256 : Py_VISIT(self->statement_cache);
281 [ + - - + ]: 256 : Py_VISIT(self->cursors);
282 [ + - - + ]: 256 : Py_VISIT(self->blobs);
283 [ + - - + ]: 256 : Py_VISIT(self->row_factory);
284 [ + - - + ]: 256 : Py_VISIT(self->text_factory);
285 [ + + + - : 256 : VISIT_CALLBACK_CONTEXT(self->trace_ctx);
- + + - -
+ ]
286 [ + + + - : 256 : VISIT_CALLBACK_CONTEXT(self->progress_ctx);
- + + - -
+ ]
287 [ + + + - : 256 : VISIT_CALLBACK_CONTEXT(self->authorizer_ctx);
- + + - -
+ ]
288 : : #undef VISIT_CALLBACK_CONTEXT
289 : 256 : return 0;
290 : : }
291 : :
292 : : static inline void
293 : 1833 : clear_callback_context(callback_context *ctx)
294 : : {
295 [ + + ]: 1833 : if (ctx != NULL) {
296 [ + + ]: 34 : Py_CLEAR(ctx->callable);
297 [ + + ]: 34 : Py_CLEAR(ctx->module);
298 : : }
299 : 1833 : }
300 : :
301 : : static int
302 : 611 : connection_clear(pysqlite_Connection *self)
303 : : {
304 [ + + ]: 611 : Py_CLEAR(self->statement_cache);
305 [ + + ]: 611 : Py_CLEAR(self->cursors);
306 [ + + ]: 611 : Py_CLEAR(self->blobs);
307 [ + + ]: 611 : Py_CLEAR(self->row_factory);
308 [ + + ]: 611 : Py_CLEAR(self->text_factory);
309 : 611 : clear_callback_context(self->trace_ctx);
310 : 611 : clear_callback_context(self->progress_ctx);
311 : 611 : clear_callback_context(self->authorizer_ctx);
312 : 611 : return 0;
313 : : }
314 : :
315 : : static void
316 : 491 : free_callback_contexts(pysqlite_Connection *self)
317 : : {
318 : 491 : set_callback_context(&self->trace_ctx, NULL);
319 : 491 : set_callback_context(&self->progress_ctx, NULL);
320 : 491 : set_callback_context(&self->authorizer_ctx, NULL);
321 : 491 : }
322 : :
323 : : static void
324 : 898 : connection_close(pysqlite_Connection *self)
325 : : {
326 [ + + ]: 898 : if (self->db) {
327 : 491 : free_callback_contexts(self);
328 : :
329 : 491 : sqlite3 *db = self->db;
330 : 491 : self->db = NULL;
331 : :
332 : 491 : Py_BEGIN_ALLOW_THREADS
333 : 491 : int rc = sqlite3_close_v2(db);
334 : : assert(rc == SQLITE_OK), (void)rc;
335 : 491 : Py_END_ALLOW_THREADS
336 : : }
337 : 898 : }
338 : :
339 : : static void
340 : 505 : connection_dealloc(pysqlite_Connection *self)
341 : : {
342 : 505 : PyTypeObject *tp = Py_TYPE(self);
343 : 505 : PyObject_GC_UnTrack(self);
344 : 505 : tp->tp_clear((PyObject *)self);
345 : :
346 : : /* Clean up if user has not called .close() explicitly. */
347 : 505 : connection_close(self);
348 : :
349 : 505 : tp->tp_free(self);
350 : 505 : Py_DECREF(tp);
351 : 505 : }
352 : :
353 : : /*[clinic input]
354 : : _sqlite3.Connection.cursor as pysqlite_connection_cursor
355 : :
356 : : factory: object = NULL
357 : :
358 : : Return a cursor for the connection.
359 : : [clinic start generated code]*/
360 : :
361 : : static PyObject *
362 : 1313 : pysqlite_connection_cursor_impl(pysqlite_Connection *self, PyObject *factory)
363 : : /*[clinic end generated code: output=562432a9e6af2aa1 input=4127345aa091b650]*/
364 : : {
365 : : PyObject* cursor;
366 : :
367 [ + + + + ]: 1313 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
368 : 9 : return NULL;
369 : : }
370 : :
371 [ + + ]: 1304 : if (factory == NULL) {
372 : 1296 : factory = (PyObject *)self->state->CursorType;
373 : : }
374 : :
375 : 1304 : cursor = PyObject_CallOneArg(factory, (PyObject *)self);
376 [ + + ]: 1304 : if (cursor == NULL)
377 : 3 : return NULL;
378 [ + + ]: 1301 : if (!PyObject_TypeCheck(cursor, self->state->CursorType)) {
379 : 2 : PyErr_Format(PyExc_TypeError,
380 : : "factory must return a cursor, not %.100s",
381 : 2 : Py_TYPE(cursor)->tp_name);
382 : 2 : Py_DECREF(cursor);
383 : 2 : return NULL;
384 : : }
385 : :
386 : 1299 : _pysqlite_drop_unused_cursor_references(self);
387 : :
388 [ + - + + ]: 1299 : if (cursor && self->row_factory != Py_None) {
389 : 15 : Py_INCREF(self->row_factory);
390 : 15 : Py_XSETREF(((pysqlite_Cursor *)cursor)->row_factory, self->row_factory);
391 : : }
392 : :
393 : 1299 : return cursor;
394 : : }
395 : :
396 : : /*[clinic input]
397 : : _sqlite3.Connection.blobopen as blobopen
398 : :
399 : : table: str
400 : : Table name.
401 : : column as col: str
402 : : Column name.
403 : : row: int
404 : : Row index.
405 : : /
406 : : *
407 : : readonly: bool(accept={int}) = False
408 : : Open the BLOB without write permissions.
409 : : name: str = "main"
410 : : Database name.
411 : :
412 : : Open and return a BLOB object.
413 : : [clinic start generated code]*/
414 : :
415 : : static PyObject *
416 : 47 : blobopen_impl(pysqlite_Connection *self, const char *table, const char *col,
417 : : int row, int readonly, const char *name)
418 : : /*[clinic end generated code: output=0c8e2e58516d0b5c input=1e7052516acfc94d]*/
419 : : {
420 [ + + - + ]: 47 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
421 : 1 : return NULL;
422 : : }
423 : :
424 : : int rc;
425 : : sqlite3_blob *blob;
426 : :
427 : 46 : Py_BEGIN_ALLOW_THREADS
428 : 46 : rc = sqlite3_blob_open(self->db, name, table, col, row, !readonly, &blob);
429 : 46 : Py_END_ALLOW_THREADS
430 : :
431 [ - + ]: 46 : if (rc == SQLITE_MISUSE) {
432 : 0 : PyErr_Format(self->state->InterfaceError, sqlite3_errstr(rc));
433 : 0 : return NULL;
434 : : }
435 [ + + ]: 46 : else if (rc != SQLITE_OK) {
436 : 4 : _pysqlite_seterror(self->state, self->db);
437 : 4 : return NULL;
438 : : }
439 : :
440 : 42 : pysqlite_Blob *obj = PyObject_GC_New(pysqlite_Blob, self->state->BlobType);
441 [ - + ]: 42 : if (obj == NULL) {
442 : 0 : goto error;
443 : : }
444 : :
445 : 42 : obj->connection = (pysqlite_Connection *)Py_NewRef(self);
446 : 42 : obj->blob = blob;
447 : 42 : obj->offset = 0;
448 : 42 : obj->in_weakreflist = NULL;
449 : :
450 : 42 : PyObject_GC_Track(obj);
451 : :
452 : : // Add our blob to connection blobs list
453 : 42 : PyObject *weakref = PyWeakref_NewRef((PyObject *)obj, NULL);
454 [ - + ]: 42 : if (weakref == NULL) {
455 : 0 : goto error;
456 : : }
457 : 42 : rc = PyList_Append(self->blobs, weakref);
458 : 42 : Py_DECREF(weakref);
459 [ - + ]: 42 : if (rc < 0) {
460 : 0 : goto error;
461 : : }
462 : :
463 : 42 : return (PyObject *)obj;
464 : :
465 : 0 : error:
466 : 0 : Py_XDECREF(obj);
467 : 0 : return NULL;
468 : : }
469 : :
470 : : /*[clinic input]
471 : : _sqlite3.Connection.close as pysqlite_connection_close
472 : :
473 : : Close the database connection.
474 : :
475 : : Any pending transaction is not committed implicitly.
476 : : [clinic start generated code]*/
477 : :
478 : : static PyObject *
479 : 393 : pysqlite_connection_close_impl(pysqlite_Connection *self)
480 : : /*[clinic end generated code: output=a546a0da212c9b97 input=b3ed5b74f6fefc06]*/
481 : : {
482 [ + + ]: 393 : if (!pysqlite_check_thread(self)) {
483 : 1 : return NULL;
484 : : }
485 : :
486 [ + + ]: 392 : if (!self->initialized) {
487 : 1 : PyTypeObject *tp = Py_TYPE(self);
488 : 1 : pysqlite_state *state = pysqlite_get_state_by_type(tp);
489 : 1 : PyErr_SetString(state->ProgrammingError,
490 : : "Base Connection.__init__ not called.");
491 : 1 : return NULL;
492 : : }
493 : :
494 : 391 : pysqlite_close_all_blobs(self);
495 [ + + ]: 391 : Py_CLEAR(self->statement_cache);
496 : 391 : connection_close(self);
497 : :
498 : 391 : Py_RETURN_NONE;
499 : : }
500 : :
501 : : /*
502 : : * Checks if a connection object is usable (i. e. not closed).
503 : : *
504 : : * 0 => error; 1 => ok
505 : : */
506 : 6839 : int pysqlite_check_connection(pysqlite_Connection* con)
507 : : {
508 [ + + ]: 6839 : if (!con->initialized) {
509 : 7 : pysqlite_state *state = pysqlite_get_state_by_type(Py_TYPE(con));
510 : 7 : PyErr_SetString(state->ProgrammingError,
511 : : "Base Connection.__init__ not called.");
512 : 7 : return 0;
513 : : }
514 : :
515 [ + + ]: 6832 : if (!con->db) {
516 : 23 : PyErr_SetString(con->state->ProgrammingError,
517 : : "Cannot operate on a closed database.");
518 : 23 : return 0;
519 : : } else {
520 : 6809 : return 1;
521 : : }
522 : : }
523 : :
524 : : /*[clinic input]
525 : : _sqlite3.Connection.commit as pysqlite_connection_commit
526 : :
527 : : Commit any pending transaction to the database.
528 : :
529 : : If there is no open transaction, this method is a no-op.
530 : : [clinic start generated code]*/
531 : :
532 : : static PyObject *
533 : 92 : pysqlite_connection_commit_impl(pysqlite_Connection *self)
534 : : /*[clinic end generated code: output=3da45579e89407f2 input=c8793c97c3446065]*/
535 : : {
536 [ + + + + ]: 92 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
537 : 2 : return NULL;
538 : : }
539 : :
540 [ + + ]: 90 : if (!sqlite3_get_autocommit(self->db)) {
541 : : int rc;
542 : :
543 : 65 : Py_BEGIN_ALLOW_THREADS
544 : : sqlite3_stmt *statement;
545 : 65 : rc = sqlite3_prepare_v2(self->db, "COMMIT", 7, &statement, NULL);
546 [ + - ]: 65 : if (rc == SQLITE_OK) {
547 : 65 : (void)sqlite3_step(statement);
548 : 65 : rc = sqlite3_finalize(statement);
549 : : }
550 : 65 : Py_END_ALLOW_THREADS
551 : :
552 [ + + ]: 65 : if (rc != SQLITE_OK) {
553 : 1 : (void)_pysqlite_seterror(self->state, self->db);
554 : 1 : return NULL;
555 : : }
556 : : }
557 : :
558 : 89 : Py_RETURN_NONE;
559 : : }
560 : :
561 : : /*[clinic input]
562 : : _sqlite3.Connection.rollback as pysqlite_connection_rollback
563 : :
564 : : Roll back to the start of any pending transaction.
565 : :
566 : : If there is no open transaction, this method is a no-op.
567 : : [clinic start generated code]*/
568 : :
569 : : static PyObject *
570 : 18 : pysqlite_connection_rollback_impl(pysqlite_Connection *self)
571 : : /*[clinic end generated code: output=b66fa0d43e7ef305 input=7f60a2f1076f16b3]*/
572 : : {
573 [ + + + + ]: 18 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
574 : 2 : return NULL;
575 : : }
576 : :
577 [ + + ]: 16 : if (!sqlite3_get_autocommit(self->db)) {
578 : : int rc;
579 : :
580 : 10 : Py_BEGIN_ALLOW_THREADS
581 : : sqlite3_stmt *statement;
582 : 10 : rc = sqlite3_prepare_v2(self->db, "ROLLBACK", 9, &statement, NULL);
583 [ + - ]: 10 : if (rc == SQLITE_OK) {
584 : 10 : (void)sqlite3_step(statement);
585 : 10 : rc = sqlite3_finalize(statement);
586 : : }
587 : 10 : Py_END_ALLOW_THREADS
588 : :
589 [ - + ]: 10 : if (rc != SQLITE_OK) {
590 : 0 : (void)_pysqlite_seterror(self->state, self->db);
591 : 0 : return NULL;
592 : : }
593 : :
594 : : }
595 : :
596 : 16 : Py_RETURN_NONE;
597 : : }
598 : :
599 : : static int
600 : 112 : _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)
601 : : {
602 [ + + ]: 112 : if (py_val == Py_None) {
603 : 21 : sqlite3_result_null(context);
604 [ + + ]: 91 : } else if (PyLong_Check(py_val)) {
605 : 75 : sqlite_int64 value = _pysqlite_long_as_int64(py_val);
606 [ + + + - ]: 75 : if (value == -1 && PyErr_Occurred())
607 : 7 : return -1;
608 : 68 : sqlite3_result_int64(context, value);
609 [ + + ]: 16 : } else if (PyFloat_Check(py_val)) {
610 : 3 : double value = PyFloat_AsDouble(py_val);
611 [ - + - - ]: 3 : if (value == -1 && PyErr_Occurred()) {
612 : 0 : return -1;
613 : : }
614 : 3 : sqlite3_result_double(context, value);
615 [ + + ]: 13 : } else if (PyUnicode_Check(py_val)) {
616 : : Py_ssize_t sz;
617 : 9 : const char *str = PyUnicode_AsUTF8AndSize(py_val, &sz);
618 [ + + ]: 9 : if (str == NULL) {
619 : 4 : return -1;
620 : : }
621 [ - + ]: 5 : if (sz > INT_MAX) {
622 : 0 : PyErr_SetString(PyExc_OverflowError,
623 : : "string is longer than INT_MAX bytes");
624 : 0 : return -1;
625 : : }
626 : 5 : sqlite3_result_text(context, str, (int)sz, SQLITE_TRANSIENT);
627 [ + + ]: 4 : } else if (PyObject_CheckBuffer(py_val)) {
628 : : Py_buffer view;
629 [ + + ]: 3 : if (PyObject_GetBuffer(py_val, &view, PyBUF_SIMPLE) != 0) {
630 : 2 : return -1;
631 : : }
632 [ - + ]: 1 : if (view.len > INT_MAX) {
633 : 0 : PyErr_SetString(PyExc_OverflowError,
634 : : "BLOB longer than INT_MAX bytes");
635 : 0 : PyBuffer_Release(&view);
636 : 0 : return -1;
637 : : }
638 : 1 : sqlite3_result_blob(context, view.buf, (int)view.len, SQLITE_TRANSIENT);
639 : 1 : PyBuffer_Release(&view);
640 : : } else {
641 : 1 : callback_context *ctx = (callback_context *)sqlite3_user_data(context);
642 : 1 : PyErr_Format(ctx->state->ProgrammingError,
643 : : "User-defined functions cannot return '%s' values to "
644 : : "SQLite",
645 : 1 : Py_TYPE(py_val)->tp_name);
646 : 1 : return -1;
647 : : }
648 : 98 : return 0;
649 : : }
650 : :
651 : : static PyObject *
652 : 142 : _pysqlite_build_py_params(sqlite3_context *context, int argc,
653 : : sqlite3_value **argv)
654 : : {
655 : : PyObject* args;
656 : : int i;
657 : : sqlite3_value* cur_value;
658 : : PyObject* cur_py_value;
659 : :
660 : 142 : args = PyTuple_New(argc);
661 [ - + ]: 142 : if (!args) {
662 : 0 : return NULL;
663 : : }
664 : :
665 [ + + ]: 267 : for (i = 0; i < argc; i++) {
666 : 125 : cur_value = argv[i];
667 [ + + + + : 125 : switch (sqlite3_value_type(argv[i])) {
+ ]
668 : 96 : case SQLITE_INTEGER:
669 : 96 : cur_py_value = PyLong_FromLongLong(sqlite3_value_int64(cur_value));
670 : 96 : break;
671 : 3 : case SQLITE_FLOAT:
672 : 3 : cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));
673 : 3 : break;
674 : 18 : case SQLITE_TEXT: {
675 : 18 : sqlite3 *db = sqlite3_context_db_handle(context);
676 : 18 : const char *text = (const char *)sqlite3_value_text(cur_value);
677 : :
678 [ - + - - ]: 18 : if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
679 : : PyErr_NoMemory();
680 : 0 : goto error;
681 : : }
682 : :
683 : 18 : Py_ssize_t size = sqlite3_value_bytes(cur_value);
684 : 18 : cur_py_value = PyUnicode_FromStringAndSize(text, size);
685 : 18 : break;
686 : : }
687 : 5 : case SQLITE_BLOB: {
688 : 5 : sqlite3 *db = sqlite3_context_db_handle(context);
689 : 5 : const void *blob = sqlite3_value_blob(cur_value);
690 : :
691 [ + + - + ]: 5 : if (blob == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
692 : : PyErr_NoMemory();
693 : 0 : goto error;
694 : : }
695 : :
696 : 5 : Py_ssize_t size = sqlite3_value_bytes(cur_value);
697 : 5 : cur_py_value = PyBytes_FromStringAndSize(blob, size);
698 : 5 : break;
699 : : }
700 : 3 : case SQLITE_NULL:
701 : : default:
702 : 3 : cur_py_value = Py_NewRef(Py_None);
703 : : }
704 : :
705 [ - + ]: 125 : if (!cur_py_value) {
706 : 0 : goto error;
707 : : }
708 : :
709 : 125 : PyTuple_SET_ITEM(args, i, cur_py_value);
710 : : }
711 : :
712 : 142 : return args;
713 : :
714 : 0 : error:
715 : 0 : Py_DECREF(args);
716 : 0 : return NULL;
717 : : }
718 : :
719 : : static void
720 : 62 : print_or_clear_traceback(callback_context *ctx)
721 : : {
722 : : assert(ctx != NULL);
723 : : assert(ctx->state != NULL);
724 [ + + ]: 62 : if (ctx->state->enable_callback_tracebacks) {
725 : 28 : PyErr_WriteUnraisable(ctx->callable);
726 : : }
727 : : else {
728 : 34 : PyErr_Clear();
729 : : }
730 : 62 : }
731 : :
732 : : // Checks the Python exception and sets the appropriate SQLite error code.
733 : : static void
734 : 48 : set_sqlite_error(sqlite3_context *context, const char *msg)
735 : : {
736 : : assert(PyErr_Occurred());
737 [ + + ]: 48 : if (PyErr_ExceptionMatches(PyExc_MemoryError)) {
738 : 2 : sqlite3_result_error_nomem(context);
739 : : }
740 [ + + ]: 46 : else if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
741 : 9 : sqlite3_result_error_toobig(context);
742 : : }
743 : : else {
744 : 37 : sqlite3_result_error(context, msg, -1);
745 : : }
746 : 48 : callback_context *ctx = (callback_context *)sqlite3_user_data(context);
747 : 48 : print_or_clear_traceback(ctx);
748 : 48 : }
749 : :
750 : : static void
751 : 52 : func_callback(sqlite3_context *context, int argc, sqlite3_value **argv)
752 : : {
753 : 52 : PyGILState_STATE threadstate = PyGILState_Ensure();
754 : :
755 : : PyObject* args;
756 : 52 : PyObject* py_retval = NULL;
757 : : int ok;
758 : :
759 : 52 : args = _pysqlite_build_py_params(context, argc, argv);
760 [ + - ]: 52 : if (args) {
761 : 52 : callback_context *ctx = (callback_context *)sqlite3_user_data(context);
762 : : assert(ctx != NULL);
763 : 52 : py_retval = PyObject_CallObject(ctx->callable, args);
764 : 52 : Py_DECREF(args);
765 : : }
766 : :
767 : 52 : ok = 0;
768 [ + + ]: 52 : if (py_retval) {
769 : 46 : ok = _pysqlite_set_result(context, py_retval) == 0;
770 : 46 : Py_DECREF(py_retval);
771 : : }
772 [ + + ]: 52 : if (!ok) {
773 : 19 : set_sqlite_error(context, "user-defined function raised exception");
774 : : }
775 : :
776 : 52 : PyGILState_Release(threadstate);
777 : 52 : }
778 : :
779 : : static void
780 : 78 : step_callback(sqlite3_context *context, int argc, sqlite3_value **params)
781 : : {
782 : 78 : PyGILState_STATE threadstate = PyGILState_Ensure();
783 : :
784 : : PyObject* args;
785 : 78 : PyObject* function_result = NULL;
786 : : PyObject** aggregate_instance;
787 : 78 : PyObject* stepmethod = NULL;
788 : :
789 : 78 : callback_context *ctx = (callback_context *)sqlite3_user_data(context);
790 : : assert(ctx != NULL);
791 : :
792 : 78 : aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
793 [ + + ]: 78 : if (*aggregate_instance == NULL) {
794 : 39 : *aggregate_instance = PyObject_CallNoArgs(ctx->callable);
795 [ + + ]: 39 : if (!*aggregate_instance) {
796 : 4 : set_sqlite_error(context,
797 : : "user-defined aggregate's '__init__' method raised error");
798 : 4 : goto error;
799 : : }
800 : : }
801 : :
802 : 74 : stepmethod = PyObject_GetAttr(*aggregate_instance, ctx->state->str_step);
803 [ + + ]: 74 : if (!stepmethod) {
804 : 4 : set_sqlite_error(context,
805 : : "user-defined aggregate's 'step' method not defined");
806 : 4 : goto error;
807 : : }
808 : :
809 : 70 : args = _pysqlite_build_py_params(context, argc, params);
810 [ - + ]: 70 : if (!args) {
811 : 0 : goto error;
812 : : }
813 : :
814 : 70 : function_result = PyObject_CallObject(stepmethod, args);
815 : 70 : Py_DECREF(args);
816 : :
817 [ + + ]: 70 : if (!function_result) {
818 : 4 : set_sqlite_error(context,
819 : : "user-defined aggregate's 'step' method raised error");
820 : : }
821 : :
822 : 66 : error:
823 : 78 : Py_XDECREF(stepmethod);
824 : 78 : Py_XDECREF(function_result);
825 : :
826 : 78 : PyGILState_Release(threadstate);
827 : 78 : }
828 : :
829 : : static void
830 : 40 : final_callback(sqlite3_context *context)
831 : : {
832 : 40 : PyGILState_STATE threadstate = PyGILState_Ensure();
833 : :
834 : : PyObject* function_result;
835 : : PyObject** aggregate_instance;
836 : : int ok;
837 : : PyObject *exception, *value, *tb;
838 : :
839 : 40 : aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, 0);
840 [ + + ]: 40 : if (aggregate_instance == NULL) {
841 : : /* No rows matched the query; the step handler was never called. */
842 : 1 : goto error;
843 : : }
844 [ + + ]: 39 : else if (!*aggregate_instance) {
845 : : /* this branch is executed if there was an exception in the aggregate's
846 : : * __init__ */
847 : :
848 : 4 : goto error;
849 : : }
850 : :
851 : : // Keep the exception (if any) of the last call to step, value, or inverse
852 : 35 : PyErr_Fetch(&exception, &value, &tb);
853 : :
854 : 35 : callback_context *ctx = (callback_context *)sqlite3_user_data(context);
855 : : assert(ctx != NULL);
856 : 35 : function_result = PyObject_CallMethodNoArgs(*aggregate_instance,
857 : 35 : ctx->state->str_finalize);
858 : 35 : Py_DECREF(*aggregate_instance);
859 : :
860 : 35 : ok = 0;
861 [ + + ]: 35 : if (function_result) {
862 : 27 : ok = _pysqlite_set_result(context, function_result) == 0;
863 : 27 : Py_DECREF(function_result);
864 : : }
865 [ + + ]: 35 : if (!ok) {
866 : 8 : int attr_err = PyErr_ExceptionMatches(PyExc_AttributeError);
867 : 8 : _PyErr_ChainExceptions(exception, value, tb);
868 : :
869 : : /* Note: contrary to the step, value, and inverse callbacks, SQLite
870 : : * does _not_, as of SQLite 3.38.0, propagate errors to sqlite3_step()
871 : : * from the finalize callback. This implies that execute*() will not
872 : : * raise OperationalError, as it normally would. */
873 [ + + ]: 8 : set_sqlite_error(context, attr_err
874 : : ? "user-defined aggregate's 'finalize' method not defined"
875 : : : "user-defined aggregate's 'finalize' method raised error");
876 : : }
877 : : else {
878 : 27 : PyErr_Restore(exception, value, tb);
879 : : }
880 : :
881 : 40 : error:
882 : 40 : PyGILState_Release(threadstate);
883 : 40 : }
884 : :
885 : 1299 : static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self)
886 : : {
887 : : PyObject* new_list;
888 : : PyObject* weakref;
889 : : int i;
890 : :
891 : : /* we only need to do this once in a while */
892 [ + + ]: 1299 : if (self->created_cursors++ < 200) {
893 : 1297 : return;
894 : : }
895 : :
896 : 2 : self->created_cursors = 0;
897 : :
898 : 2 : new_list = PyList_New(0);
899 [ - + ]: 2 : if (!new_list) {
900 : 0 : return;
901 : : }
902 : :
903 [ + + ]: 406 : for (i = 0; i < PyList_Size(self->cursors); i++) {
904 : 404 : weakref = PyList_GetItem(self->cursors, i);
905 [ + + ]: 404 : if (PyWeakref_GetObject(weakref) != Py_None) {
906 [ - + ]: 4 : if (PyList_Append(new_list, weakref) != 0) {
907 : 0 : Py_DECREF(new_list);
908 : 0 : return;
909 : : }
910 : : }
911 : : }
912 : :
913 : 2 : Py_SETREF(self->cursors, new_list);
914 : : }
915 : :
916 : : /* Allocate a UDF/callback context structure. In order to ensure that the state
917 : : * pointer always outlives the callback context, we make sure it owns a
918 : : * reference to the module itself. create_callback_context() is always called
919 : : * from connection methods, so we use the defining class to fetch the module
920 : : * pointer.
921 : : */
922 : : static callback_context *
923 : 785 : create_callback_context(PyTypeObject *cls, PyObject *callable)
924 : : {
925 : 785 : callback_context *ctx = PyMem_Malloc(sizeof(callback_context));
926 [ + - ]: 785 : if (ctx != NULL) {
927 : 785 : PyObject *module = PyType_GetModule(cls);
928 : 785 : ctx->callable = Py_NewRef(callable);
929 : 785 : ctx->module = Py_NewRef(module);
930 : 785 : ctx->state = pysqlite_get_state(module);
931 : : }
932 : 785 : return ctx;
933 : : }
934 : :
935 : : static void
936 : 785 : free_callback_context(callback_context *ctx)
937 : : {
938 : : assert(ctx != NULL);
939 : 785 : Py_XDECREF(ctx->callable);
940 : 785 : Py_XDECREF(ctx->module);
941 : 785 : PyMem_Free(ctx);
942 : 785 : }
943 : :
944 : : static void
945 : 1537 : set_callback_context(callback_context **ctx_pp, callback_context *ctx)
946 : : {
947 : : assert(ctx_pp != NULL);
948 : 1537 : callback_context *tmp = *ctx_pp;
949 : 1537 : *ctx_pp = ctx;
950 [ + + ]: 1537 : if (tmp != NULL) {
951 : 50 : free_callback_context(tmp);
952 : : }
953 : 1537 : }
954 : :
955 : : static void
956 : 735 : destructor_callback(void *ctx)
957 : : {
958 [ + - ]: 735 : if (ctx != NULL) {
959 : : // This function may be called without the GIL held, so we need to
960 : : // ensure that we destroy 'ctx' with the GIL held.
961 : 735 : PyGILState_STATE gstate = PyGILState_Ensure();
962 : 735 : free_callback_context((callback_context *)ctx);
963 : 735 : PyGILState_Release(gstate);
964 : : }
965 : 735 : }
966 : :
967 : : /*[clinic input]
968 : : _sqlite3.Connection.create_function as pysqlite_connection_create_function
969 : :
970 : : cls: defining_class
971 : : /
972 : : name: str
973 : : narg: int
974 : : func: object
975 : : *
976 : : deterministic: bool = False
977 : :
978 : : Creates a new function.
979 : : [clinic start generated code]*/
980 : :
981 : : static PyObject *
982 : 565 : pysqlite_connection_create_function_impl(pysqlite_Connection *self,
983 : : PyTypeObject *cls, const char *name,
984 : : int narg, PyObject *func,
985 : : int deterministic)
986 : : /*[clinic end generated code: output=8a811529287ad240 input=b3e8e1d8ddaffbef]*/
987 : : {
988 : : int rc;
989 : 565 : int flags = SQLITE_UTF8;
990 : :
991 [ + - + + ]: 565 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
992 : 2 : return NULL;
993 : : }
994 : :
995 [ + + ]: 563 : if (deterministic) {
996 : : #if SQLITE_VERSION_NUMBER < 3008003
997 : : PyErr_SetString(self->NotSupportedError,
998 : : "deterministic=True requires SQLite 3.8.3 or higher");
999 : : return NULL;
1000 : : #else
1001 [ - + ]: 1 : if (sqlite3_libversion_number() < 3008003) {
1002 : 0 : PyErr_SetString(self->NotSupportedError,
1003 : : "deterministic=True requires SQLite 3.8.3 or higher");
1004 : 0 : return NULL;
1005 : : }
1006 : 1 : flags |= SQLITE_DETERMINISTIC;
1007 : : #endif
1008 : : }
1009 : 563 : callback_context *ctx = create_callback_context(cls, func);
1010 [ - + ]: 563 : if (ctx == NULL) {
1011 : 0 : return NULL;
1012 : : }
1013 : 563 : rc = sqlite3_create_function_v2(self->db, name, narg, flags, ctx,
1014 : : func_callback,
1015 : : NULL,
1016 : : NULL,
1017 : : &destructor_callback); // will decref func
1018 : :
1019 [ + + ]: 563 : if (rc != SQLITE_OK) {
1020 : : /* Workaround for SQLite bug: no error code or string is available here */
1021 : 2 : PyErr_SetString(self->OperationalError, "Error creating function");
1022 : 2 : return NULL;
1023 : : }
1024 : 561 : Py_RETURN_NONE;
1025 : : }
1026 : :
1027 : : #ifdef HAVE_WINDOW_FUNCTIONS
1028 : : /*
1029 : : * Regarding the 'inverse' aggregate callback:
1030 : : * This method is only required by window aggregate functions, not
1031 : : * ordinary aggregate function implementations. It is invoked to remove
1032 : : * a row from the current window. The function arguments, if any,
1033 : : * correspond to the row being removed.
1034 : : */
1035 : : static void
1036 : 22 : inverse_callback(sqlite3_context *context, int argc, sqlite3_value **params)
1037 : : {
1038 : 22 : PyGILState_STATE gilstate = PyGILState_Ensure();
1039 : :
1040 : 22 : callback_context *ctx = (callback_context *)sqlite3_user_data(context);
1041 : : assert(ctx != NULL);
1042 : :
1043 : 22 : int size = sizeof(PyObject *);
1044 : 22 : PyObject **cls = (PyObject **)sqlite3_aggregate_context(context, size);
1045 : : assert(cls != NULL);
1046 : : assert(*cls != NULL);
1047 : :
1048 : 22 : PyObject *method = PyObject_GetAttr(*cls, ctx->state->str_inverse);
1049 [ + + ]: 22 : if (method == NULL) {
1050 : 2 : set_sqlite_error(context,
1051 : : "user-defined aggregate's 'inverse' method not defined");
1052 : 2 : goto exit;
1053 : : }
1054 : :
1055 : 20 : PyObject *args = _pysqlite_build_py_params(context, argc, params);
1056 [ - + ]: 20 : if (args == NULL) {
1057 : 0 : set_sqlite_error(context,
1058 : : "unable to build arguments for user-defined aggregate's "
1059 : : "'inverse' method");
1060 : 0 : goto exit;
1061 : : }
1062 : :
1063 : 20 : PyObject *res = PyObject_CallObject(method, args);
1064 : 20 : Py_DECREF(args);
1065 [ + + ]: 20 : if (res == NULL) {
1066 : 2 : set_sqlite_error(context,
1067 : : "user-defined aggregate's 'inverse' method raised error");
1068 : 2 : goto exit;
1069 : : }
1070 : 18 : Py_DECREF(res);
1071 : :
1072 : 22 : exit:
1073 : 22 : Py_XDECREF(method);
1074 : 22 : PyGILState_Release(gilstate);
1075 : 22 : }
1076 : :
1077 : : /*
1078 : : * Regarding the 'value' aggregate callback:
1079 : : * This method is only required by window aggregate functions, not
1080 : : * ordinary aggregate function implementations. It is invoked to return
1081 : : * the current value of the aggregate.
1082 : : */
1083 : : static void
1084 : 43 : value_callback(sqlite3_context *context)
1085 : : {
1086 : 43 : PyGILState_STATE gilstate = PyGILState_Ensure();
1087 : :
1088 : 43 : callback_context *ctx = (callback_context *)sqlite3_user_data(context);
1089 : : assert(ctx != NULL);
1090 : :
1091 : 43 : int size = sizeof(PyObject *);
1092 : 43 : PyObject **cls = (PyObject **)sqlite3_aggregate_context(context, size);
1093 : : assert(cls != NULL);
1094 : : assert(*cls != NULL);
1095 : :
1096 : 43 : PyObject *res = PyObject_CallMethodNoArgs(*cls, ctx->state->str_value);
1097 [ + + ]: 43 : if (res == NULL) {
1098 : 4 : int attr_err = PyErr_ExceptionMatches(PyExc_AttributeError);
1099 [ + + ]: 4 : set_sqlite_error(context, attr_err
1100 : : ? "user-defined aggregate's 'value' method not defined"
1101 : : : "user-defined aggregate's 'value' method raised error");
1102 : : }
1103 : : else {
1104 : 39 : int rc = _pysqlite_set_result(context, res);
1105 : 39 : Py_DECREF(res);
1106 [ + + ]: 39 : if (rc < 0) {
1107 : 1 : set_sqlite_error(context,
1108 : : "unable to set result from user-defined aggregate's "
1109 : : "'value' method");
1110 : : }
1111 : : }
1112 : :
1113 : 43 : PyGILState_Release(gilstate);
1114 : 43 : }
1115 : :
1116 : : /*[clinic input]
1117 : : _sqlite3.Connection.create_window_function as create_window_function
1118 : :
1119 : : cls: defining_class
1120 : : name: str
1121 : : The name of the SQL aggregate window function to be created or
1122 : : redefined.
1123 : : num_params: int
1124 : : The number of arguments the step and inverse methods takes.
1125 : : aggregate_class: object
1126 : : A class with step(), finalize(), value(), and inverse() methods.
1127 : : Set to None to clear the window function.
1128 : : /
1129 : :
1130 : : Creates or redefines an aggregate window function. Non-standard.
1131 : : [clinic start generated code]*/
1132 : :
1133 : : static PyObject *
1134 : 32 : create_window_function_impl(pysqlite_Connection *self, PyTypeObject *cls,
1135 : : const char *name, int num_params,
1136 : : PyObject *aggregate_class)
1137 : : /*[clinic end generated code: output=5332cd9464522235 input=46d57a54225b5228]*/
1138 : : {
1139 [ - + ]: 32 : if (sqlite3_libversion_number() < 3025000) {
1140 : 0 : PyErr_SetString(self->NotSupportedError,
1141 : : "create_window_function() requires "
1142 : : "SQLite 3.25.0 or higher");
1143 : 0 : return NULL;
1144 : : }
1145 : :
1146 [ + + - + ]: 32 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1147 : 1 : return NULL;
1148 : : }
1149 : :
1150 : 31 : int flags = SQLITE_UTF8;
1151 : : int rc;
1152 [ + + ]: 31 : if (Py_IsNone(aggregate_class)) {
1153 : 1 : rc = sqlite3_create_window_function(self->db, name, num_params, flags,
1154 : : 0, 0, 0, 0, 0, 0);
1155 : : }
1156 : : else {
1157 : 30 : callback_context *ctx = create_callback_context(cls, aggregate_class);
1158 [ - + ]: 30 : if (ctx == NULL) {
1159 : 0 : return NULL;
1160 : : }
1161 : 30 : rc = sqlite3_create_window_function(self->db, name, num_params, flags,
1162 : : ctx,
1163 : : &step_callback,
1164 : : &final_callback,
1165 : : &value_callback,
1166 : : &inverse_callback,
1167 : : &destructor_callback);
1168 : : }
1169 : :
1170 [ + + ]: 31 : if (rc != SQLITE_OK) {
1171 : : // Errors are not set on the database connection, so we cannot
1172 : : // use _pysqlite_seterror().
1173 : 1 : PyErr_SetString(self->ProgrammingError, sqlite3_errstr(rc));
1174 : 1 : return NULL;
1175 : : }
1176 : 30 : Py_RETURN_NONE;
1177 : : }
1178 : : #endif
1179 : :
1180 : : /*[clinic input]
1181 : : _sqlite3.Connection.create_aggregate as pysqlite_connection_create_aggregate
1182 : :
1183 : : cls: defining_class
1184 : : /
1185 : : name: str
1186 : : n_arg: int
1187 : : aggregate_class: object
1188 : :
1189 : : Creates a new aggregate.
1190 : : [clinic start generated code]*/
1191 : :
1192 : : static PyObject *
1193 : 136 : pysqlite_connection_create_aggregate_impl(pysqlite_Connection *self,
1194 : : PyTypeObject *cls,
1195 : : const char *name, int n_arg,
1196 : : PyObject *aggregate_class)
1197 : : /*[clinic end generated code: output=1b02d0f0aec7ff96 input=68a2a26366d4c686]*/
1198 : : {
1199 : : int rc;
1200 : :
1201 [ + - + + ]: 136 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1202 : 1 : return NULL;
1203 : : }
1204 : :
1205 : 135 : callback_context *ctx = create_callback_context(cls, aggregate_class);
1206 [ - + ]: 135 : if (ctx == NULL) {
1207 : 0 : return NULL;
1208 : : }
1209 : 135 : rc = sqlite3_create_function_v2(self->db, name, n_arg, SQLITE_UTF8, ctx,
1210 : : 0,
1211 : : &step_callback,
1212 : : &final_callback,
1213 : : &destructor_callback); // will decref func
1214 [ - + ]: 135 : if (rc != SQLITE_OK) {
1215 : : /* Workaround for SQLite bug: no error code or string is available here */
1216 : 0 : PyErr_SetString(self->OperationalError, "Error creating aggregate");
1217 : 0 : return NULL;
1218 : : }
1219 : 135 : Py_RETURN_NONE;
1220 : : }
1221 : :
1222 : : static int
1223 : 21 : authorizer_callback(void *ctx, int action, const char *arg1,
1224 : : const char *arg2 , const char *dbname,
1225 : : const char *access_attempt_source)
1226 : : {
1227 : 21 : PyGILState_STATE gilstate = PyGILState_Ensure();
1228 : :
1229 : : PyObject *ret;
1230 : 21 : int rc = SQLITE_DENY;
1231 : :
1232 : : assert(ctx != NULL);
1233 : 21 : PyObject *callable = ((callback_context *)ctx)->callable;
1234 : 21 : ret = PyObject_CallFunction(callable, "issss", action, arg1, arg2, dbname,
1235 : : access_attempt_source);
1236 : :
1237 [ + + ]: 21 : if (ret == NULL) {
1238 : 4 : print_or_clear_traceback(ctx);
1239 : 4 : rc = SQLITE_DENY;
1240 : : }
1241 : : else {
1242 [ + + ]: 17 : if (PyLong_Check(ret)) {
1243 : 15 : rc = _PyLong_AsInt(ret);
1244 [ + + + - ]: 15 : if (rc == -1 && PyErr_Occurred()) {
1245 : 2 : print_or_clear_traceback(ctx);
1246 : 2 : rc = SQLITE_DENY;
1247 : : }
1248 : : }
1249 : : else {
1250 : 2 : rc = SQLITE_DENY;
1251 : : }
1252 : 17 : Py_DECREF(ret);
1253 : : }
1254 : :
1255 : 21 : PyGILState_Release(gilstate);
1256 : 21 : return rc;
1257 : : }
1258 : :
1259 : : static int
1260 : 147 : progress_callback(void *ctx)
1261 : : {
1262 : 147 : PyGILState_STATE gilstate = PyGILState_Ensure();
1263 : :
1264 : : int rc;
1265 : : PyObject *ret;
1266 : :
1267 : : assert(ctx != NULL);
1268 : 147 : PyObject *callable = ((callback_context *)ctx)->callable;
1269 : 147 : ret = PyObject_CallNoArgs(callable);
1270 [ + + ]: 147 : if (!ret) {
1271 : : /* abort query if error occurred */
1272 : 2 : rc = -1;
1273 : : }
1274 : : else {
1275 : 145 : rc = PyObject_IsTrue(ret);
1276 : 145 : Py_DECREF(ret);
1277 : : }
1278 [ + + ]: 147 : if (rc < 0) {
1279 : 4 : print_or_clear_traceback(ctx);
1280 : : }
1281 : :
1282 : 147 : PyGILState_Release(gilstate);
1283 : 147 : return rc;
1284 : : }
1285 : :
1286 : : #ifdef HAVE_TRACE_V2
1287 : : /*
1288 : : * From https://sqlite.org/c3ref/trace_v2.html:
1289 : : * The integer return value from the callback is currently ignored, though this
1290 : : * may change in future releases. Callback implementations should return zero
1291 : : * to ensure future compatibility.
1292 : : */
1293 : : static int
1294 : 52 : trace_callback(unsigned int type, void *ctx, void *stmt, void *sql)
1295 : : #else
1296 : : static void
1297 : : trace_callback(void *ctx, const char *sql)
1298 : : #endif
1299 : : {
1300 : : #ifdef HAVE_TRACE_V2
1301 [ - + ]: 52 : if (type != SQLITE_TRACE_STMT) {
1302 : 0 : return 0;
1303 : : }
1304 : : #endif
1305 : :
1306 : 52 : PyGILState_STATE gilstate = PyGILState_Ensure();
1307 : :
1308 : : assert(ctx != NULL);
1309 : 52 : pysqlite_state *state = ((callback_context *)ctx)->state;
1310 : : assert(state != NULL);
1311 : :
1312 : 52 : PyObject *py_statement = NULL;
1313 : : #ifdef HAVE_TRACE_V2
1314 : 52 : const char *expanded_sql = sqlite3_expanded_sql((sqlite3_stmt *)stmt);
1315 [ + + ]: 52 : if (expanded_sql == NULL) {
1316 : 2 : sqlite3 *db = sqlite3_db_handle((sqlite3_stmt *)stmt);
1317 [ - + ]: 2 : if (sqlite3_errcode(db) == SQLITE_NOMEM) {
1318 : : (void)PyErr_NoMemory();
1319 : 0 : goto exit;
1320 : : }
1321 : :
1322 : 2 : PyErr_SetString(state->DataError,
1323 : : "Expanded SQL string exceeds the maximum string length");
1324 : 2 : print_or_clear_traceback((callback_context *)ctx);
1325 : :
1326 : : // Fall back to unexpanded sql
1327 : 2 : py_statement = PyUnicode_FromString((const char *)sql);
1328 : : }
1329 : : else {
1330 : 50 : py_statement = PyUnicode_FromString(expanded_sql);
1331 : 50 : sqlite3_free((void *)expanded_sql);
1332 : : }
1333 : : #else
1334 : : if (sql == NULL) {
1335 : : PyErr_SetString(state->DataError,
1336 : : "Expanded SQL string exceeds the maximum string length");
1337 : : print_or_clear_traceback((callback_context *)ctx);
1338 : : goto exit;
1339 : : }
1340 : : py_statement = PyUnicode_FromString(sql);
1341 : : #endif
1342 [ + - ]: 52 : if (py_statement) {
1343 : 52 : PyObject *callable = ((callback_context *)ctx)->callable;
1344 : 52 : PyObject *ret = PyObject_CallOneArg(callable, py_statement);
1345 : 52 : Py_DECREF(py_statement);
1346 : 52 : Py_XDECREF(ret);
1347 : : }
1348 [ + + ]: 52 : if (PyErr_Occurred()) {
1349 : 2 : print_or_clear_traceback((callback_context *)ctx);
1350 : : }
1351 : :
1352 : 50 : exit:
1353 : 52 : PyGILState_Release(gilstate);
1354 : : #ifdef HAVE_TRACE_V2
1355 : 52 : return 0;
1356 : : #endif
1357 : : }
1358 : :
1359 : : /*[clinic input]
1360 : : _sqlite3.Connection.set_authorizer as pysqlite_connection_set_authorizer
1361 : :
1362 : : cls: defining_class
1363 : : /
1364 : : authorizer_callback as callable: object
1365 : :
1366 : : Sets authorizer callback.
1367 : : [clinic start generated code]*/
1368 : :
1369 : : static PyObject *
1370 : 21 : pysqlite_connection_set_authorizer_impl(pysqlite_Connection *self,
1371 : : PyTypeObject *cls,
1372 : : PyObject *callable)
1373 : : /*[clinic end generated code: output=75fa60114fc971c3 input=605d32ba92dd3eca]*/
1374 : : {
1375 [ + + + + ]: 21 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1376 : 2 : return NULL;
1377 : : }
1378 : :
1379 : : int rc;
1380 [ + + ]: 19 : if (callable == Py_None) {
1381 : 5 : rc = sqlite3_set_authorizer(self->db, NULL, NULL);
1382 : 5 : set_callback_context(&self->authorizer_ctx, NULL);
1383 : : }
1384 : : else {
1385 : 14 : callback_context *ctx = create_callback_context(cls, callable);
1386 [ - + ]: 14 : if (ctx == NULL) {
1387 : 0 : return NULL;
1388 : : }
1389 : 14 : rc = sqlite3_set_authorizer(self->db, authorizer_callback, ctx);
1390 : 14 : set_callback_context(&self->authorizer_ctx, ctx);
1391 : : }
1392 [ - + ]: 19 : if (rc != SQLITE_OK) {
1393 : 0 : PyErr_SetString(self->OperationalError,
1394 : : "Error setting authorizer callback");
1395 : 0 : set_callback_context(&self->authorizer_ctx, NULL);
1396 : 0 : return NULL;
1397 : : }
1398 : 19 : Py_RETURN_NONE;
1399 : : }
1400 : :
1401 : : /*[clinic input]
1402 : : _sqlite3.Connection.set_progress_handler as pysqlite_connection_set_progress_handler
1403 : :
1404 : : cls: defining_class
1405 : : /
1406 : : progress_handler as callable: object
1407 : : n: int
1408 : :
1409 : : Sets progress handler callback.
1410 : : [clinic start generated code]*/
1411 : :
1412 : : static PyObject *
1413 : 14 : pysqlite_connection_set_progress_handler_impl(pysqlite_Connection *self,
1414 : : PyTypeObject *cls,
1415 : : PyObject *callable, int n)
1416 : : /*[clinic end generated code: output=0739957fd8034a50 input=f7c1837984bd86db]*/
1417 : : {
1418 [ + - + + ]: 14 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1419 : 1 : return NULL;
1420 : : }
1421 : :
1422 [ + + ]: 13 : if (callable == Py_None) {
1423 : : /* None clears the progress handler previously set */
1424 : 2 : sqlite3_progress_handler(self->db, 0, 0, (void*)0);
1425 : 2 : set_callback_context(&self->progress_ctx, NULL);
1426 : : }
1427 : : else {
1428 : 11 : callback_context *ctx = create_callback_context(cls, callable);
1429 [ - + ]: 11 : if (ctx == NULL) {
1430 : 0 : return NULL;
1431 : : }
1432 : 11 : sqlite3_progress_handler(self->db, n, progress_callback, ctx);
1433 : 11 : set_callback_context(&self->progress_ctx, ctx);
1434 : : }
1435 : 13 : Py_RETURN_NONE;
1436 : : }
1437 : :
1438 : : /*[clinic input]
1439 : : _sqlite3.Connection.set_trace_callback as pysqlite_connection_set_trace_callback
1440 : :
1441 : : cls: defining_class
1442 : : /
1443 : : trace_callback as callable: object
1444 : :
1445 : : Sets a trace callback called for each SQL statement (passed as unicode).
1446 : : [clinic start generated code]*/
1447 : :
1448 : : static PyObject *
1449 : 33 : pysqlite_connection_set_trace_callback_impl(pysqlite_Connection *self,
1450 : : PyTypeObject *cls,
1451 : : PyObject *callable)
1452 : : /*[clinic end generated code: output=d91048c03bfcee05 input=351a94210c5f81bb]*/
1453 : : {
1454 [ + + - + ]: 33 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1455 : 1 : return NULL;
1456 : : }
1457 : :
1458 [ + + ]: 32 : if (callable == Py_None) {
1459 : : /*
1460 : : * None clears the trace callback previously set
1461 : : *
1462 : : * Ref.
1463 : : * - https://sqlite.org/c3ref/c_trace.html
1464 : : * - https://sqlite.org/c3ref/trace_v2.html
1465 : : */
1466 : : #ifdef HAVE_TRACE_V2
1467 : 7 : sqlite3_trace_v2(self->db, SQLITE_TRACE_STMT, 0, 0);
1468 : : #else
1469 : : sqlite3_trace(self->db, 0, (void*)0);
1470 : : #endif
1471 : 7 : set_callback_context(&self->trace_ctx, NULL);
1472 : : }
1473 : : else {
1474 : 25 : callback_context *ctx = create_callback_context(cls, callable);
1475 [ - + ]: 25 : if (ctx == NULL) {
1476 : 0 : return NULL;
1477 : : }
1478 : : #ifdef HAVE_TRACE_V2
1479 : 25 : sqlite3_trace_v2(self->db, SQLITE_TRACE_STMT, trace_callback, ctx);
1480 : : #else
1481 : : sqlite3_trace(self->db, trace_callback, ctx);
1482 : : #endif
1483 : 25 : set_callback_context(&self->trace_ctx, ctx);
1484 : : }
1485 : :
1486 : 32 : Py_RETURN_NONE;
1487 : : }
1488 : :
1489 : : #ifdef PY_SQLITE_ENABLE_LOAD_EXTENSION
1490 : : /*[clinic input]
1491 : : _sqlite3.Connection.enable_load_extension as pysqlite_connection_enable_load_extension
1492 : :
1493 : : enable as onoff: bool(accept={int})
1494 : : /
1495 : :
1496 : : Enable dynamic loading of SQLite extension modules.
1497 : : [clinic start generated code]*/
1498 : :
1499 : : static PyObject *
1500 : : pysqlite_connection_enable_load_extension_impl(pysqlite_Connection *self,
1501 : : int onoff)
1502 : : /*[clinic end generated code: output=9cac37190d388baf input=5f00e93f7a9d3540]*/
1503 : : {
1504 : : int rc;
1505 : :
1506 : : if (PySys_Audit("sqlite3.enable_load_extension",
1507 : : "OO", self, onoff ? Py_True : Py_False) < 0) {
1508 : : return NULL;
1509 : : }
1510 : :
1511 : : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1512 : : return NULL;
1513 : : }
1514 : :
1515 : : rc = sqlite3_enable_load_extension(self->db, onoff);
1516 : :
1517 : : if (rc != SQLITE_OK) {
1518 : : PyErr_SetString(self->OperationalError,
1519 : : "Error enabling load extension");
1520 : : return NULL;
1521 : : } else {
1522 : : Py_RETURN_NONE;
1523 : : }
1524 : : }
1525 : :
1526 : : /*[clinic input]
1527 : : _sqlite3.Connection.load_extension as pysqlite_connection_load_extension
1528 : :
1529 : : name as extension_name: str
1530 : : /
1531 : :
1532 : : Load SQLite extension module.
1533 : : [clinic start generated code]*/
1534 : :
1535 : : static PyObject *
1536 : : pysqlite_connection_load_extension_impl(pysqlite_Connection *self,
1537 : : const char *extension_name)
1538 : : /*[clinic end generated code: output=47eb1d7312bc97a7 input=edd507389d89d621]*/
1539 : : {
1540 : : int rc;
1541 : : char* errmsg;
1542 : :
1543 : : if (PySys_Audit("sqlite3.load_extension", "Os", self, extension_name) < 0) {
1544 : : return NULL;
1545 : : }
1546 : :
1547 : : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1548 : : return NULL;
1549 : : }
1550 : :
1551 : : rc = sqlite3_load_extension(self->db, extension_name, 0, &errmsg);
1552 : : if (rc != 0) {
1553 : : PyErr_SetString(self->OperationalError, errmsg);
1554 : : return NULL;
1555 : : } else {
1556 : : Py_RETURN_NONE;
1557 : : }
1558 : : }
1559 : : #endif
1560 : :
1561 : 8439 : int pysqlite_check_thread(pysqlite_Connection* self)
1562 : : {
1563 [ + + ]: 8439 : if (self->check_same_thread) {
1564 [ + + ]: 8432 : if (PyThread_get_thread_ident() != self->thread_ident) {
1565 : 17 : PyErr_Format(self->ProgrammingError,
1566 : : "SQLite objects created in a thread can only be used in that same thread. "
1567 : : "The object was created in thread id %lu and this is thread id %lu.",
1568 : : self->thread_ident, PyThread_get_thread_ident());
1569 : 17 : return 0;
1570 : : }
1571 : :
1572 : : }
1573 : 8422 : return 1;
1574 : : }
1575 : :
1576 : 32 : static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)
1577 : : {
1578 [ + + ]: 32 : if (!pysqlite_check_connection(self)) {
1579 : 1 : return NULL;
1580 : : }
1581 [ + + ]: 31 : if (self->isolation_level != NULL) {
1582 : 28 : return PyUnicode_FromString(self->isolation_level);
1583 : : }
1584 : 3 : Py_RETURN_NONE;
1585 : : }
1586 : :
1587 : 2 : static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)
1588 : : {
1589 [ + + ]: 2 : if (!pysqlite_check_connection(self)) {
1590 : 1 : return NULL;
1591 : : }
1592 : 1 : return PyLong_FromLong(sqlite3_total_changes(self->db));
1593 : : }
1594 : :
1595 : 9 : static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* self, void* unused)
1596 : : {
1597 [ + + ]: 9 : if (!pysqlite_check_connection(self)) {
1598 : 1 : return NULL;
1599 : : }
1600 [ + + ]: 8 : if (!sqlite3_get_autocommit(self->db)) {
1601 : 3 : Py_RETURN_TRUE;
1602 : : }
1603 : 5 : Py_RETURN_FALSE;
1604 : : }
1605 : :
1606 : : static int
1607 : 51 : pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored))
1608 : : {
1609 [ + + ]: 51 : if (isolation_level == NULL) {
1610 : 1 : PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
1611 : 1 : return -1;
1612 : : }
1613 [ + + ]: 50 : if (Py_IsNone(isolation_level)) {
1614 : 7 : self->isolation_level = NULL;
1615 : :
1616 : : // Execute a COMMIT to re-enable autocommit mode
1617 : 7 : PyObject *res = pysqlite_connection_commit_impl(self);
1618 [ - + ]: 7 : if (res == NULL) {
1619 : 0 : return -1;
1620 : : }
1621 : 7 : Py_DECREF(res);
1622 : 7 : return 0;
1623 : : }
1624 [ + + ]: 43 : if (!isolation_level_converter(isolation_level, &self->isolation_level)) {
1625 : 13 : return -1;
1626 : : }
1627 : 30 : return 0;
1628 : : }
1629 : :
1630 : : static PyObject *
1631 : 1578 : pysqlite_connection_call(pysqlite_Connection *self, PyObject *args,
1632 : : PyObject *kwargs)
1633 : : {
1634 : : PyObject* sql;
1635 : : pysqlite_Statement* statement;
1636 : :
1637 [ + - + + ]: 1578 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1638 : 1 : return NULL;
1639 : : }
1640 : :
1641 [ + + - + ]: 1577 : if (!_PyArg_NoKeywords(MODULE_NAME ".Connection", kwargs))
1642 : 0 : return NULL;
1643 : :
1644 [ + + ]: 1577 : if (!PyArg_ParseTuple(args, "U", &sql))
1645 : 1 : return NULL;
1646 : :
1647 : 1576 : statement = pysqlite_statement_create(self, sql);
1648 [ + + ]: 1576 : if (statement == NULL) {
1649 : 46 : return NULL;
1650 : : }
1651 : :
1652 : 1530 : return (PyObject*)statement;
1653 : : }
1654 : :
1655 : : /*[clinic input]
1656 : : _sqlite3.Connection.execute as pysqlite_connection_execute
1657 : :
1658 : : sql: unicode
1659 : : parameters: object = NULL
1660 : : /
1661 : :
1662 : : Executes an SQL statement.
1663 : : [clinic start generated code]*/
1664 : :
1665 : : static PyObject *
1666 : 859 : pysqlite_connection_execute_impl(pysqlite_Connection *self, PyObject *sql,
1667 : : PyObject *parameters)
1668 : : /*[clinic end generated code: output=5be05ae01ee17ee4 input=27aa7792681ddba2]*/
1669 : : {
1670 : 859 : PyObject* result = 0;
1671 : :
1672 : 859 : PyObject *cursor = pysqlite_connection_cursor_impl(self, NULL);
1673 [ + + ]: 859 : if (!cursor) {
1674 : 1 : goto error;
1675 : : }
1676 : :
1677 : 858 : result = _pysqlite_query_execute((pysqlite_Cursor *)cursor, 0, sql, parameters);
1678 [ + + ]: 858 : if (!result) {
1679 [ - + ]: 35 : Py_CLEAR(cursor);
1680 : : }
1681 : :
1682 : 823 : error:
1683 : 859 : Py_XDECREF(result);
1684 : :
1685 : 859 : return cursor;
1686 : : }
1687 : :
1688 : : /*[clinic input]
1689 : : _sqlite3.Connection.executemany as pysqlite_connection_executemany
1690 : :
1691 : : sql: unicode
1692 : : parameters: object
1693 : : /
1694 : :
1695 : : Repeatedly executes an SQL statement.
1696 : : [clinic start generated code]*/
1697 : :
1698 : : static PyObject *
1699 : 37 : pysqlite_connection_executemany_impl(pysqlite_Connection *self,
1700 : : PyObject *sql, PyObject *parameters)
1701 : : /*[clinic end generated code: output=776cd2fd20bfe71f input=495be76551d525db]*/
1702 : : {
1703 : 37 : PyObject* result = 0;
1704 : :
1705 : 37 : PyObject *cursor = pysqlite_connection_cursor_impl(self, NULL);
1706 [ + + ]: 37 : if (!cursor) {
1707 : 2 : goto error;
1708 : : }
1709 : :
1710 : 35 : result = _pysqlite_query_execute((pysqlite_Cursor *)cursor, 1, sql, parameters);
1711 [ + - ]: 35 : if (!result) {
1712 [ # # ]: 0 : Py_CLEAR(cursor);
1713 : : }
1714 : :
1715 : 35 : error:
1716 : 37 : Py_XDECREF(result);
1717 : :
1718 : 37 : return cursor;
1719 : : }
1720 : :
1721 : : /*[clinic input]
1722 : : _sqlite3.Connection.executescript as pysqlite_connection_executescript
1723 : :
1724 : : sql_script as script_obj: object
1725 : : /
1726 : :
1727 : : Executes multiple SQL statements at once.
1728 : : [clinic start generated code]*/
1729 : :
1730 : : static PyObject *
1731 : 21 : pysqlite_connection_executescript(pysqlite_Connection *self,
1732 : : PyObject *script_obj)
1733 : : /*[clinic end generated code: output=4c4f9d77aa0ae37d input=f6e5f1ccfa313db4]*/
1734 : : {
1735 : 21 : PyObject* result = 0;
1736 : :
1737 : 21 : PyObject *cursor = pysqlite_connection_cursor_impl(self, NULL);
1738 [ + + ]: 21 : if (!cursor) {
1739 : 1 : goto error;
1740 : : }
1741 : :
1742 : 20 : PyObject *meth = self->state->str_executescript; // borrowed ref.
1743 : 20 : result = PyObject_CallMethodObjArgs(cursor, meth, script_obj, NULL);
1744 [ + + ]: 20 : if (!result) {
1745 [ - + ]: 1 : Py_CLEAR(cursor);
1746 : : }
1747 : :
1748 : 19 : error:
1749 : 21 : Py_XDECREF(result);
1750 : :
1751 : 21 : return cursor;
1752 : : }
1753 : :
1754 : : /* ------------------------- COLLATION CODE ------------------------ */
1755 : :
1756 : : static int
1757 : 8 : collation_callback(void *context, int text1_length, const void *text1_data,
1758 : : int text2_length, const void *text2_data)
1759 : : {
1760 : 8 : PyGILState_STATE gilstate = PyGILState_Ensure();
1761 : :
1762 : 8 : PyObject* string1 = 0;
1763 : 8 : PyObject* string2 = 0;
1764 : 8 : PyObject* retval = NULL;
1765 : : long longval;
1766 : 8 : int result = 0;
1767 : :
1768 : : /* This callback may be executed multiple times per sqlite3_step(). Bail if
1769 : : * the previous call failed */
1770 [ - + ]: 8 : if (PyErr_Occurred()) {
1771 : 0 : goto finally;
1772 : : }
1773 : :
1774 : 8 : string1 = PyUnicode_FromStringAndSize((const char*)text1_data, text1_length);
1775 : 8 : string2 = PyUnicode_FromStringAndSize((const char*)text2_data, text2_length);
1776 : :
1777 [ + - - + ]: 8 : if (!string1 || !string2) {
1778 : 0 : goto finally; /* failed to allocate strings */
1779 : : }
1780 : :
1781 : 8 : callback_context *ctx = (callback_context *)context;
1782 : : assert(ctx != NULL);
1783 : 8 : PyObject *args[] = { NULL, string1, string2 }; // Borrowed refs.
1784 : 8 : size_t nargsf = 2 | PY_VECTORCALL_ARGUMENTS_OFFSET;
1785 : 8 : retval = PyObject_Vectorcall(ctx->callable, args + 1, nargsf, NULL);
1786 [ - + ]: 8 : if (retval == NULL) {
1787 : : /* execution failed */
1788 : 0 : goto finally;
1789 : : }
1790 : :
1791 : 8 : longval = PyLong_AsLongAndOverflow(retval, &result);
1792 [ - + - - ]: 8 : if (longval == -1 && PyErr_Occurred()) {
1793 : 0 : PyErr_Clear();
1794 : 0 : result = 0;
1795 : : }
1796 [ - + ]: 8 : else if (!result) {
1797 [ + - ]: 8 : if (longval > 0)
1798 : 8 : result = 1;
1799 [ # # ]: 0 : else if (longval < 0)
1800 : 0 : result = -1;
1801 : : }
1802 : :
1803 : 0 : finally:
1804 : 8 : Py_XDECREF(string1);
1805 : 8 : Py_XDECREF(string2);
1806 : 8 : Py_XDECREF(retval);
1807 : 8 : PyGILState_Release(gilstate);
1808 : 8 : return result;
1809 : : }
1810 : :
1811 : : /*[clinic input]
1812 : : _sqlite3.Connection.interrupt as pysqlite_connection_interrupt
1813 : :
1814 : : Abort any pending database operation.
1815 : : [clinic start generated code]*/
1816 : :
1817 : : static PyObject *
1818 : 2 : pysqlite_connection_interrupt_impl(pysqlite_Connection *self)
1819 : : /*[clinic end generated code: output=f193204bc9e70b47 input=75ad03ade7012859]*/
1820 : : {
1821 : 2 : PyObject* retval = NULL;
1822 : :
1823 [ + + ]: 2 : if (!pysqlite_check_connection(self)) {
1824 : 1 : goto finally;
1825 : : }
1826 : :
1827 : 1 : sqlite3_interrupt(self->db);
1828 : :
1829 : 1 : retval = Py_NewRef(Py_None);
1830 : :
1831 : 2 : finally:
1832 : 2 : return retval;
1833 : : }
1834 : :
1835 : : /* Function author: Paul Kippes <kippesp@gmail.com>
1836 : : * Class method of Connection to call the Python function _iterdump
1837 : : * of the sqlite3 module.
1838 : : */
1839 : : /*[clinic input]
1840 : : _sqlite3.Connection.iterdump as pysqlite_connection_iterdump
1841 : :
1842 : : Returns iterator to the dump of the database in an SQL text format.
1843 : : [clinic start generated code]*/
1844 : :
1845 : : static PyObject *
1846 : 5 : pysqlite_connection_iterdump_impl(pysqlite_Connection *self)
1847 : : /*[clinic end generated code: output=586997aaf9808768 input=1911ca756066da89]*/
1848 : : {
1849 [ + + ]: 5 : if (!pysqlite_check_connection(self)) {
1850 : 1 : return NULL;
1851 : : }
1852 : :
1853 : 4 : PyObject *iterdump = _PyImport_GetModuleAttrString(MODULE_NAME ".dump", "_iterdump");
1854 [ - + ]: 4 : if (!iterdump) {
1855 [ # # ]: 0 : if (!PyErr_Occurred()) {
1856 : 0 : PyErr_SetString(self->OperationalError,
1857 : : "Failed to obtain _iterdump() reference");
1858 : : }
1859 : 0 : return NULL;
1860 : : }
1861 : :
1862 : 4 : PyObject *retval = PyObject_CallOneArg(iterdump, (PyObject *)self);
1863 : 4 : Py_DECREF(iterdump);
1864 : 4 : return retval;
1865 : : }
1866 : :
1867 : : /*[clinic input]
1868 : : _sqlite3.Connection.backup as pysqlite_connection_backup
1869 : :
1870 : : target: object(type='pysqlite_Connection *', subclass_of='clinic_state()->ConnectionType')
1871 : : *
1872 : : pages: int = -1
1873 : : progress: object = None
1874 : : name: str = "main"
1875 : : sleep: double = 0.250
1876 : :
1877 : : Makes a backup of the database.
1878 : : [clinic start generated code]*/
1879 : :
1880 : : static PyObject *
1881 : 15 : pysqlite_connection_backup_impl(pysqlite_Connection *self,
1882 : : pysqlite_Connection *target, int pages,
1883 : : PyObject *progress, const char *name,
1884 : : double sleep)
1885 : : /*[clinic end generated code: output=306a3e6a38c36334 input=c6519d0f59d0fd7f]*/
1886 : : {
1887 : : int rc;
1888 : 15 : int sleep_ms = (int)(sleep * 1000.0);
1889 : : sqlite3 *bck_conn;
1890 : : sqlite3_backup *bck_handle;
1891 : :
1892 [ + - + + ]: 15 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1893 : 1 : return NULL;
1894 : : }
1895 : :
1896 [ + + ]: 14 : if (!pysqlite_check_connection(target)) {
1897 : 1 : return NULL;
1898 : : }
1899 : :
1900 [ + + ]: 13 : if (target == self) {
1901 : 1 : PyErr_SetString(PyExc_ValueError, "target cannot be the same connection instance");
1902 : 1 : return NULL;
1903 : : }
1904 : :
1905 : : #if SQLITE_VERSION_NUMBER < 3008008
1906 : : /* Since 3.8.8 this is already done, per commit
1907 : : https://www.sqlite.org/src/info/169b5505498c0a7e */
1908 : : if (!sqlite3_get_autocommit(target->db)) {
1909 : : PyErr_SetString(self->OperationalError, "target is in transaction");
1910 : : return NULL;
1911 : : }
1912 : : #endif
1913 : :
1914 [ + + + + ]: 12 : if (progress != Py_None && !PyCallable_Check(progress)) {
1915 : 1 : PyErr_SetString(PyExc_TypeError, "progress argument must be a callable");
1916 : 1 : return NULL;
1917 : : }
1918 : :
1919 [ - + ]: 11 : if (pages == 0) {
1920 : 0 : pages = -1;
1921 : : }
1922 : :
1923 : 11 : bck_conn = target->db;
1924 : :
1925 : 11 : Py_BEGIN_ALLOW_THREADS
1926 : 11 : bck_handle = sqlite3_backup_init(bck_conn, "main", self->db, name);
1927 : 11 : Py_END_ALLOW_THREADS
1928 : :
1929 [ + + ]: 11 : if (bck_handle == NULL) {
1930 : 2 : _pysqlite_seterror(self->state, bck_conn);
1931 : 2 : return NULL;
1932 : : }
1933 : :
1934 : : do {
1935 : 12 : Py_BEGIN_ALLOW_THREADS
1936 : 12 : rc = sqlite3_backup_step(bck_handle, pages);
1937 : 12 : Py_END_ALLOW_THREADS
1938 : :
1939 [ + + ]: 12 : if (progress != Py_None) {
1940 : 8 : int remaining = sqlite3_backup_remaining(bck_handle);
1941 : 8 : int pagecount = sqlite3_backup_pagecount(bck_handle);
1942 : 8 : PyObject *res = PyObject_CallFunction(progress, "iii", rc,
1943 : : remaining, pagecount);
1944 [ + + ]: 8 : if (res == NULL) {
1945 : : /* Callback failed: abort backup and bail. */
1946 : 1 : Py_BEGIN_ALLOW_THREADS
1947 : 1 : sqlite3_backup_finish(bck_handle);
1948 : 1 : Py_END_ALLOW_THREADS
1949 : 1 : return NULL;
1950 : : }
1951 : 7 : Py_DECREF(res);
1952 : : }
1953 : :
1954 : : /* Sleep for a while if there are still further pages to copy and
1955 : : the engine could not make any progress */
1956 [ + - - + ]: 11 : if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED) {
1957 : 0 : Py_BEGIN_ALLOW_THREADS
1958 : 0 : sqlite3_sleep(sleep_ms);
1959 : 0 : Py_END_ALLOW_THREADS
1960 : : }
1961 [ + + - + : 11 : } while (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED);
- + ]
1962 : :
1963 : 8 : Py_BEGIN_ALLOW_THREADS
1964 : 8 : rc = sqlite3_backup_finish(bck_handle);
1965 : 8 : Py_END_ALLOW_THREADS
1966 : :
1967 [ - + ]: 8 : if (rc != SQLITE_OK) {
1968 : 0 : _pysqlite_seterror(self->state, bck_conn);
1969 : 0 : return NULL;
1970 : : }
1971 : :
1972 : 8 : Py_RETURN_NONE;
1973 : : }
1974 : :
1975 : : /*[clinic input]
1976 : : _sqlite3.Connection.create_collation as pysqlite_connection_create_collation
1977 : :
1978 : : cls: defining_class
1979 : : name: str
1980 : : callback as callable: object
1981 : : /
1982 : :
1983 : : Creates a collation function.
1984 : : [clinic start generated code]*/
1985 : :
1986 : : static PyObject *
1987 : 11 : pysqlite_connection_create_collation_impl(pysqlite_Connection *self,
1988 : : PyTypeObject *cls,
1989 : : const char *name,
1990 : : PyObject *callable)
1991 : : /*[clinic end generated code: output=32d339e97869c378 input=f67ecd2e31e61ad3]*/
1992 : : {
1993 [ + + - + ]: 11 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1994 : 1 : return NULL;
1995 : : }
1996 : :
1997 : 10 : callback_context *ctx = NULL;
1998 : : int rc;
1999 : 10 : int flags = SQLITE_UTF8;
2000 [ + + ]: 10 : if (callable == Py_None) {
2001 : 2 : rc = sqlite3_create_collation_v2(self->db, name, flags,
2002 : : NULL, NULL, NULL);
2003 : : }
2004 : : else {
2005 [ + + ]: 8 : if (!PyCallable_Check(callable)) {
2006 : 1 : PyErr_SetString(PyExc_TypeError, "parameter must be callable");
2007 : 1 : return NULL;
2008 : : }
2009 : 7 : ctx = create_callback_context(cls, callable);
2010 [ - + ]: 7 : if (ctx == NULL) {
2011 : 0 : return NULL;
2012 : : }
2013 : 7 : rc = sqlite3_create_collation_v2(self->db, name, flags, ctx,
2014 : : &collation_callback,
2015 : : &destructor_callback);
2016 : : }
2017 : :
2018 [ - + ]: 9 : if (rc != SQLITE_OK) {
2019 : : /* Unlike other sqlite3_* functions, the destructor callback is _not_
2020 : : * called if sqlite3_create_collation_v2() fails, so we have to free
2021 : : * the context before returning.
2022 : : */
2023 [ # # ]: 0 : if (callable != Py_None) {
2024 : 0 : free_callback_context(ctx);
2025 : : }
2026 : 0 : _pysqlite_seterror(self->state, self->db);
2027 : 0 : return NULL;
2028 : : }
2029 : :
2030 : 9 : Py_RETURN_NONE;
2031 : : }
2032 : :
2033 : : #ifdef PY_SQLITE_HAVE_SERIALIZE
2034 : : /*[clinic input]
2035 : : _sqlite3.Connection.serialize as serialize
2036 : :
2037 : : *
2038 : : name: str = "main"
2039 : : Which database to serialize.
2040 : :
2041 : : Serialize a database into a byte string.
2042 : :
2043 : : For an ordinary on-disk database file, the serialization is just a copy of the
2044 : : disk file. For an in-memory database or a "temp" database, the serialization is
2045 : : the same sequence of bytes which would be written to disk if that database
2046 : : were backed up to disk.
2047 : : [clinic start generated code]*/
2048 : :
2049 : : static PyObject *
2050 : 2 : serialize_impl(pysqlite_Connection *self, const char *name)
2051 : : /*[clinic end generated code: output=97342b0e55239dd3 input=d2eb5194a65abe2b]*/
2052 : : {
2053 [ + + - + ]: 2 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
2054 : 1 : return NULL;
2055 : : }
2056 : :
2057 : : /* If SQLite has a contiguous memory representation of the database, we can
2058 : : * avoid memory allocations, so we try with the no-copy flag first.
2059 : : */
2060 : : sqlite3_int64 size;
2061 : 1 : unsigned int flags = SQLITE_SERIALIZE_NOCOPY;
2062 : : const char *data;
2063 : :
2064 : 1 : Py_BEGIN_ALLOW_THREADS
2065 : 1 : data = (const char *)sqlite3_serialize(self->db, name, &size, flags);
2066 [ + - ]: 1 : if (data == NULL) {
2067 : 1 : flags &= ~SQLITE_SERIALIZE_NOCOPY;
2068 : 1 : data = (const char *)sqlite3_serialize(self->db, name, &size, flags);
2069 : : }
2070 : 1 : Py_END_ALLOW_THREADS
2071 : :
2072 [ - + ]: 1 : if (data == NULL) {
2073 : 0 : PyErr_Format(self->OperationalError, "unable to serialize '%s'",
2074 : : name);
2075 : 0 : return NULL;
2076 : : }
2077 : 1 : PyObject *res = PyBytes_FromStringAndSize(data, (Py_ssize_t)size);
2078 [ + - ]: 1 : if (!(flags & SQLITE_SERIALIZE_NOCOPY)) {
2079 : 1 : sqlite3_free((void *)data);
2080 : : }
2081 : 1 : return res;
2082 : : }
2083 : :
2084 : : /*[clinic input]
2085 : : _sqlite3.Connection.deserialize as deserialize
2086 : :
2087 : : data: Py_buffer(accept={buffer, str})
2088 : : The serialized database content.
2089 : : /
2090 : : *
2091 : : name: str = "main"
2092 : : Which database to reopen with the deserialization.
2093 : :
2094 : : Load a serialized database.
2095 : :
2096 : : The deserialize interface causes the database connection to disconnect from the
2097 : : target database, and then reopen it as an in-memory database based on the given
2098 : : serialized data.
2099 : :
2100 : : The deserialize interface will fail with SQLITE_BUSY if the database is
2101 : : currently in a read transaction or is involved in a backup operation.
2102 : : [clinic start generated code]*/
2103 : :
2104 : : static PyObject *
2105 : 3 : deserialize_impl(pysqlite_Connection *self, Py_buffer *data,
2106 : : const char *name)
2107 : : /*[clinic end generated code: output=e394c798b98bad89 input=1be4ca1faacf28f2]*/
2108 : : {
2109 [ + + - + ]: 3 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
2110 : 1 : return NULL;
2111 : : }
2112 : :
2113 : : /* Transfer ownership of the buffer to SQLite:
2114 : : * - Move buffer from Py to SQLite
2115 : : * - Tell SQLite to free buffer memory
2116 : : * - Tell SQLite that it is permitted to grow the resulting database
2117 : : *
2118 : : * Make sure we don't overflow sqlite3_deserialize(); it accepts a signed
2119 : : * 64-bit int as its data size argument.
2120 : : *
2121 : : * We can safely use sqlite3_malloc64 here, since it was introduced before
2122 : : * the serialize APIs.
2123 : : */
2124 : : if (data->len > 9223372036854775807) { // (1 << 63) - 1
2125 : : PyErr_SetString(PyExc_OverflowError, "'data' is too large");
2126 : : return NULL;
2127 : : }
2128 : :
2129 : 2 : sqlite3_int64 size = (sqlite3_int64)data->len;
2130 : 2 : unsigned char *buf = sqlite3_malloc64(size);
2131 [ - + ]: 2 : if (buf == NULL) {
2132 : : return PyErr_NoMemory();
2133 : : }
2134 : :
2135 : 2 : const unsigned int flags = SQLITE_DESERIALIZE_FREEONCLOSE |
2136 : : SQLITE_DESERIALIZE_RESIZEABLE;
2137 : : int rc;
2138 : 2 : Py_BEGIN_ALLOW_THREADS
2139 : 2 : (void)memcpy(buf, data->buf, data->len);
2140 : 2 : rc = sqlite3_deserialize(self->db, name, buf, size, size, flags);
2141 : 2 : Py_END_ALLOW_THREADS
2142 : :
2143 [ - + ]: 2 : if (rc != SQLITE_OK) {
2144 : 0 : (void)_pysqlite_seterror(self->state, self->db);
2145 : 0 : return NULL;
2146 : : }
2147 : 2 : Py_RETURN_NONE;
2148 : : }
2149 : : #endif // PY_SQLITE_HAVE_SERIALIZE
2150 : :
2151 : :
2152 : : /*[clinic input]
2153 : : _sqlite3.Connection.__enter__ as pysqlite_connection_enter
2154 : :
2155 : : Called when the connection is used as a context manager.
2156 : :
2157 : : Returns itself as a convenience to the caller.
2158 : : [clinic start generated code]*/
2159 : :
2160 : : static PyObject *
2161 : 45 : pysqlite_connection_enter_impl(pysqlite_Connection *self)
2162 : : /*[clinic end generated code: output=457b09726d3e9dcd input=127d7a4f17e86d8f]*/
2163 : : {
2164 [ + + ]: 45 : if (!pysqlite_check_connection(self)) {
2165 : 1 : return NULL;
2166 : : }
2167 : 44 : return Py_NewRef((PyObject *)self);
2168 : : }
2169 : :
2170 : : /*[clinic input]
2171 : : _sqlite3.Connection.__exit__ as pysqlite_connection_exit
2172 : :
2173 : : type as exc_type: object
2174 : : value as exc_value: object
2175 : : traceback as exc_tb: object
2176 : : /
2177 : :
2178 : : Called when the connection is used as a context manager.
2179 : :
2180 : : If there was any exception, a rollback takes place; otherwise we commit.
2181 : : [clinic start generated code]*/
2182 : :
2183 : : static PyObject *
2184 : 44 : pysqlite_connection_exit_impl(pysqlite_Connection *self, PyObject *exc_type,
2185 : : PyObject *exc_value, PyObject *exc_tb)
2186 : : /*[clinic end generated code: output=0705200e9321202a input=bd66f1532c9c54a7]*/
2187 : : {
2188 : 44 : int commit = 0;
2189 : : PyObject* result;
2190 : :
2191 [ + + + - : 44 : if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
+ - ]
2192 : 40 : commit = 1;
2193 : 40 : result = pysqlite_connection_commit_impl(self);
2194 : : }
2195 : : else {
2196 : 4 : result = pysqlite_connection_rollback_impl(self);
2197 : : }
2198 : :
2199 [ + + ]: 44 : if (result == NULL) {
2200 [ + - ]: 1 : if (commit) {
2201 : : /* Commit failed; try to rollback in order to unlock the database.
2202 : : * If rollback also fails, chain the exceptions. */
2203 : : PyObject *exc, *val, *tb;
2204 : 1 : PyErr_Fetch(&exc, &val, &tb);
2205 : 1 : result = pysqlite_connection_rollback_impl(self);
2206 [ - + ]: 1 : if (result == NULL) {
2207 : 0 : _PyErr_ChainExceptions(exc, val, tb);
2208 : : }
2209 : : else {
2210 : 1 : Py_DECREF(result);
2211 : 1 : PyErr_Restore(exc, val, tb);
2212 : : }
2213 : : }
2214 : 1 : return NULL;
2215 : : }
2216 : 43 : Py_DECREF(result);
2217 : :
2218 : 43 : Py_RETURN_FALSE;
2219 : : }
2220 : :
2221 : : /*[clinic input]
2222 : : _sqlite3.Connection.setlimit as setlimit
2223 : :
2224 : : category: int
2225 : : The limit category to be set.
2226 : : limit: int
2227 : : The new limit. If the new limit is a negative number, the limit is
2228 : : unchanged.
2229 : : /
2230 : :
2231 : : Set connection run-time limits.
2232 : :
2233 : : Attempts to increase a limit above its hard upper bound are silently truncated
2234 : : to the hard upper bound. Regardless of whether or not the limit was changed,
2235 : : the prior value of the limit is returned.
2236 : : [clinic start generated code]*/
2237 : :
2238 : : static PyObject *
2239 : 20 : setlimit_impl(pysqlite_Connection *self, int category, int limit)
2240 : : /*[clinic end generated code: output=0d208213f8d68ccd input=9bd469537e195635]*/
2241 : : {
2242 [ + + - + ]: 20 : if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
2243 : 2 : return NULL;
2244 : : }
2245 : :
2246 : 18 : int old_limit = sqlite3_limit(self->db, category, limit);
2247 [ + + ]: 18 : if (old_limit < 0) {
2248 : 2 : PyErr_SetString(self->ProgrammingError, "'category' is out of bounds");
2249 : 2 : return NULL;
2250 : : }
2251 : 16 : return PyLong_FromLong(old_limit);
2252 : : }
2253 : :
2254 : : /*[clinic input]
2255 : : _sqlite3.Connection.getlimit as getlimit
2256 : :
2257 : : category: int
2258 : : The limit category to be queried.
2259 : : /
2260 : :
2261 : : Get connection run-time limits.
2262 : : [clinic start generated code]*/
2263 : :
2264 : : static PyObject *
2265 : 4 : getlimit_impl(pysqlite_Connection *self, int category)
2266 : : /*[clinic end generated code: output=7c3f5d11f24cecb1 input=61e0849fb4fb058f]*/
2267 : : {
2268 : 4 : return setlimit_impl(self, category, -1);
2269 : : }
2270 : :
2271 : :
2272 : : static const char connection_doc[] =
2273 : : PyDoc_STR("SQLite database connection object.");
2274 : :
2275 : : static PyGetSetDef connection_getset[] = {
2276 : : {"isolation_level", (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
2277 : : {"total_changes", (getter)pysqlite_connection_get_total_changes, (setter)0},
2278 : : {"in_transaction", (getter)pysqlite_connection_get_in_transaction, (setter)0},
2279 : : {NULL}
2280 : : };
2281 : :
2282 : : static PyMethodDef connection_methods[] = {
2283 : : PYSQLITE_CONNECTION_BACKUP_METHODDEF
2284 : : PYSQLITE_CONNECTION_CLOSE_METHODDEF
2285 : : PYSQLITE_CONNECTION_COMMIT_METHODDEF
2286 : : PYSQLITE_CONNECTION_CREATE_AGGREGATE_METHODDEF
2287 : : PYSQLITE_CONNECTION_CREATE_COLLATION_METHODDEF
2288 : : PYSQLITE_CONNECTION_CREATE_FUNCTION_METHODDEF
2289 : : PYSQLITE_CONNECTION_CURSOR_METHODDEF
2290 : : PYSQLITE_CONNECTION_ENABLE_LOAD_EXTENSION_METHODDEF
2291 : : PYSQLITE_CONNECTION_ENTER_METHODDEF
2292 : : PYSQLITE_CONNECTION_EXECUTEMANY_METHODDEF
2293 : : PYSQLITE_CONNECTION_EXECUTESCRIPT_METHODDEF
2294 : : PYSQLITE_CONNECTION_EXECUTE_METHODDEF
2295 : : PYSQLITE_CONNECTION_EXIT_METHODDEF
2296 : : PYSQLITE_CONNECTION_INTERRUPT_METHODDEF
2297 : : PYSQLITE_CONNECTION_ITERDUMP_METHODDEF
2298 : : PYSQLITE_CONNECTION_LOAD_EXTENSION_METHODDEF
2299 : : PYSQLITE_CONNECTION_ROLLBACK_METHODDEF
2300 : : PYSQLITE_CONNECTION_SET_AUTHORIZER_METHODDEF
2301 : : PYSQLITE_CONNECTION_SET_PROGRESS_HANDLER_METHODDEF
2302 : : PYSQLITE_CONNECTION_SET_TRACE_CALLBACK_METHODDEF
2303 : : SETLIMIT_METHODDEF
2304 : : GETLIMIT_METHODDEF
2305 : : SERIALIZE_METHODDEF
2306 : : DESERIALIZE_METHODDEF
2307 : : CREATE_WINDOW_FUNCTION_METHODDEF
2308 : : BLOBOPEN_METHODDEF
2309 : : {NULL, NULL}
2310 : : };
2311 : :
2312 : : static struct PyMemberDef connection_members[] =
2313 : : {
2314 : : {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), READONLY},
2315 : : {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), READONLY},
2316 : : {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), READONLY},
2317 : : {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), READONLY},
2318 : : {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), READONLY},
2319 : : {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), READONLY},
2320 : : {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), READONLY},
2321 : : {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), READONLY},
2322 : : {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), READONLY},
2323 : : {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), READONLY},
2324 : : {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)},
2325 : : {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)},
2326 : : {NULL}
2327 : : };
2328 : :
2329 : : static PyType_Slot connection_slots[] = {
2330 : : {Py_tp_dealloc, connection_dealloc},
2331 : : {Py_tp_doc, (void *)connection_doc},
2332 : : {Py_tp_methods, connection_methods},
2333 : : {Py_tp_members, connection_members},
2334 : : {Py_tp_getset, connection_getset},
2335 : : {Py_tp_init, pysqlite_connection_init},
2336 : : {Py_tp_call, pysqlite_connection_call},
2337 : : {Py_tp_traverse, connection_traverse},
2338 : : {Py_tp_clear, connection_clear},
2339 : : {0, NULL},
2340 : : };
2341 : :
2342 : : static PyType_Spec connection_spec = {
2343 : : .name = MODULE_NAME ".Connection",
2344 : : .basicsize = sizeof(pysqlite_Connection),
2345 : : .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
2346 : : Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
2347 : : .slots = connection_slots,
2348 : : };
2349 : :
2350 : : int
2351 : 5 : pysqlite_connection_setup_types(PyObject *module)
2352 : : {
2353 : 5 : PyObject *type = PyType_FromModuleAndSpec(module, &connection_spec, NULL);
2354 [ - + ]: 5 : if (type == NULL) {
2355 : 0 : return -1;
2356 : : }
2357 : 5 : pysqlite_state *state = pysqlite_get_state(module);
2358 : 5 : state->ConnectionType = (PyTypeObject *)type;
2359 : 5 : return 0;
2360 : : }
|
