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 "cache.h"
25 #include "module.h"
26 #include "structmember.h" // PyMemberDef
27 #include "connection.h"
28 #include "statement.h"
29 #include "cursor.h"
30 #include "prepare_protocol.h"
31 #include "util.h"
32
33 #define ACTION_FINALIZE 1
34 #define ACTION_RESET 2
35
36 #if SQLITE_VERSION_NUMBER >= 3014000
37 #define HAVE_TRACE_V2
38 #endif
39
40 #include "clinic/connection.c.h"
41 /*[clinic input]
42 module _sqlite3
43 class _sqlite3.Connection "pysqlite_Connection *" "pysqlite_ConnectionType"
44 [clinic start generated code]*/
45 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=aa796073bd8f69db]*/
46
47 _Py_IDENTIFIER(cursor);
48
49 static const char * const begin_statements[] = {
50 "BEGIN ",
51 "BEGIN DEFERRED",
52 "BEGIN IMMEDIATE",
53 "BEGIN EXCLUSIVE",
54 NULL
55 };
56
57 static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored));
58 static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self);
59
60 static int
pysqlite_connection_init(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)61 pysqlite_connection_init(pysqlite_Connection *self, PyObject *args,
62 PyObject *kwargs)
63 {
64 static char *kwlist[] = {
65 "database", "timeout", "detect_types", "isolation_level",
66 "check_same_thread", "factory", "cached_statements", "uri",
67 NULL
68 };
69
70 const char* database;
71 PyObject* database_obj;
72 int detect_types = 0;
73 PyObject* isolation_level = NULL;
74 PyObject* factory = NULL;
75 int check_same_thread = 1;
76 int cached_statements = 100;
77 int uri = 0;
78 double timeout = 5.0;
79 int rc;
80
81 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|diOiOip", kwlist,
82 PyUnicode_FSConverter, &database_obj, &timeout, &detect_types,
83 &isolation_level, &check_same_thread,
84 &factory, &cached_statements, &uri))
85 {
86 return -1;
87 }
88
89 if (PySys_Audit("sqlite3.connect", "O", database_obj) < 0) {
90 Py_DECREF(database_obj);
91 return -1;
92 }
93
94 database = PyBytes_AsString(database_obj);
95
96 self->begin_statement = NULL;
97
98 Py_CLEAR(self->statement_cache);
99 Py_CLEAR(self->statements);
100 Py_CLEAR(self->cursors);
101
102 Py_INCREF(Py_None);
103 Py_XSETREF(self->row_factory, Py_None);
104
105 Py_INCREF(&PyUnicode_Type);
106 Py_XSETREF(self->text_factory, (PyObject*)&PyUnicode_Type);
107
108 Py_BEGIN_ALLOW_THREADS
109 rc = sqlite3_open_v2(database, &self->db,
110 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
111 (uri ? SQLITE_OPEN_URI : 0), NULL);
112 Py_END_ALLOW_THREADS
113
114 Py_DECREF(database_obj);
115
116 if (self->db == NULL && rc == SQLITE_NOMEM) {
117 PyErr_NoMemory();
118 return -1;
119 }
120 if (rc != SQLITE_OK) {
121 _pysqlite_seterror(self->db, NULL);
122 return -1;
123 }
124
125 if (!isolation_level) {
126 isolation_level = PyUnicode_FromString("");
127 if (!isolation_level) {
128 return -1;
129 }
130 } else {
131 Py_INCREF(isolation_level);
132 }
133 Py_CLEAR(self->isolation_level);
134 if (pysqlite_connection_set_isolation_level(self, isolation_level, NULL) != 0) {
135 Py_DECREF(isolation_level);
136 return -1;
137 }
138 Py_DECREF(isolation_level);
139
140 self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)pysqlite_CacheType, "Oi", self, cached_statements);
141 if (PyErr_Occurred()) {
142 return -1;
143 }
144
145 self->created_statements = 0;
146 self->created_cursors = 0;
147
148 /* Create lists of weak references to statements/cursors */
149 self->statements = PyList_New(0);
150 self->cursors = PyList_New(0);
151 if (!self->statements || !self->cursors) {
152 return -1;
153 }
154
155 /* By default, the Cache class INCREFs the factory in its initializer, and
156 * decrefs it in its deallocator method. Since this would create a circular
157 * reference here, we're breaking it by decrementing self, and telling the
158 * cache class to not decref the factory (self) in its deallocator.
159 */
160 self->statement_cache->decref_factory = 0;
161 Py_DECREF(self);
162
163 self->detect_types = detect_types;
164 self->timeout = timeout;
165 (void)sqlite3_busy_timeout(self->db, (int)(timeout*1000));
166 self->thread_ident = PyThread_get_thread_ident();
167 self->check_same_thread = check_same_thread;
168
169 self->function_pinboard_trace_callback = NULL;
170 self->function_pinboard_progress_handler = NULL;
171 self->function_pinboard_authorizer_cb = NULL;
172
173 Py_XSETREF(self->collations, PyDict_New());
174 if (!self->collations) {
175 return -1;
176 }
177
178 self->Warning = pysqlite_Warning;
179 self->Error = pysqlite_Error;
180 self->InterfaceError = pysqlite_InterfaceError;
181 self->DatabaseError = pysqlite_DatabaseError;
182 self->DataError = pysqlite_DataError;
183 self->OperationalError = pysqlite_OperationalError;
184 self->IntegrityError = pysqlite_IntegrityError;
185 self->InternalError = pysqlite_InternalError;
186 self->ProgrammingError = pysqlite_ProgrammingError;
187 self->NotSupportedError = pysqlite_NotSupportedError;
188
189 if (PySys_Audit("sqlite3.connect/handle", "O", self) < 0) {
190 return -1;
191 }
192
193 self->initialized = 1;
194
195 return 0;
196 }
197
198 /* action in (ACTION_RESET, ACTION_FINALIZE) */
199 static void
pysqlite_do_all_statements(pysqlite_Connection * self,int action,int reset_cursors)200 pysqlite_do_all_statements(pysqlite_Connection *self, int action,
201 int reset_cursors)
202 {
203 int i;
204 PyObject* weakref;
205 PyObject* statement;
206 pysqlite_Cursor* cursor;
207
208 for (i = 0; i < PyList_Size(self->statements); i++) {
209 weakref = PyList_GetItem(self->statements, i);
210 statement = PyWeakref_GetObject(weakref);
211 if (statement != Py_None) {
212 Py_INCREF(statement);
213 if (action == ACTION_RESET) {
214 (void)pysqlite_statement_reset((pysqlite_Statement*)statement);
215 } else {
216 (void)pysqlite_statement_finalize((pysqlite_Statement*)statement);
217 }
218 Py_DECREF(statement);
219 }
220 }
221
222 if (reset_cursors) {
223 for (i = 0; i < PyList_Size(self->cursors); i++) {
224 weakref = PyList_GetItem(self->cursors, i);
225 cursor = (pysqlite_Cursor*)PyWeakref_GetObject(weakref);
226 if ((PyObject*)cursor != Py_None) {
227 cursor->reset = 1;
228 }
229 }
230 }
231 }
232
233 static int
connection_traverse(pysqlite_Connection * self,visitproc visit,void * arg)234 connection_traverse(pysqlite_Connection *self, visitproc visit, void *arg)
235 {
236 Py_VISIT(Py_TYPE(self));
237 Py_VISIT(self->isolation_level);
238 Py_VISIT(self->statement_cache);
239 Py_VISIT(self->statements);
240 Py_VISIT(self->cursors);
241 Py_VISIT(self->row_factory);
242 Py_VISIT(self->text_factory);
243 Py_VISIT(self->function_pinboard_trace_callback);
244 Py_VISIT(self->function_pinboard_progress_handler);
245 Py_VISIT(self->function_pinboard_authorizer_cb);
246 Py_VISIT(self->collations);
247 return 0;
248 }
249
250 static int
connection_clear(pysqlite_Connection * self)251 connection_clear(pysqlite_Connection *self)
252 {
253 Py_CLEAR(self->isolation_level);
254 Py_CLEAR(self->statement_cache);
255 Py_CLEAR(self->statements);
256 Py_CLEAR(self->cursors);
257 Py_CLEAR(self->row_factory);
258 Py_CLEAR(self->text_factory);
259 Py_CLEAR(self->function_pinboard_trace_callback);
260 Py_CLEAR(self->function_pinboard_progress_handler);
261 Py_CLEAR(self->function_pinboard_authorizer_cb);
262 Py_CLEAR(self->collations);
263 return 0;
264 }
265
266 static void
connection_dealloc(pysqlite_Connection * self)267 connection_dealloc(pysqlite_Connection *self)
268 {
269 PyTypeObject *tp = Py_TYPE(self);
270 PyObject_GC_UnTrack(self);
271 tp->tp_clear((PyObject *)self);
272
273 /* Clean up if user has not called .close() explicitly. */
274 if (self->db) {
275 sqlite3_close_v2(self->db);
276 }
277
278 tp->tp_free(self);
279 Py_DECREF(tp);
280 }
281
282 /*
283 * Registers a cursor with the connection.
284 *
285 * 0 => error; 1 => ok
286 */
pysqlite_connection_register_cursor(pysqlite_Connection * connection,PyObject * cursor)287 int pysqlite_connection_register_cursor(pysqlite_Connection* connection, PyObject* cursor)
288 {
289 PyObject* weakref;
290
291 weakref = PyWeakref_NewRef((PyObject*)cursor, NULL);
292 if (!weakref) {
293 goto error;
294 }
295
296 if (PyList_Append(connection->cursors, weakref) != 0) {
297 Py_CLEAR(weakref);
298 goto error;
299 }
300
301 Py_DECREF(weakref);
302
303 return 1;
304 error:
305 return 0;
306 }
307
308 /*[clinic input]
309 _sqlite3.Connection.cursor as pysqlite_connection_cursor
310
311 factory: object = NULL
312
313 Return a cursor for the connection.
314 [clinic start generated code]*/
315
316 static PyObject *
pysqlite_connection_cursor_impl(pysqlite_Connection * self,PyObject * factory)317 pysqlite_connection_cursor_impl(pysqlite_Connection *self, PyObject *factory)
318 /*[clinic end generated code: output=562432a9e6af2aa1 input=4127345aa091b650]*/
319 {
320 PyObject* cursor;
321
322 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
323 return NULL;
324 }
325
326 if (factory == NULL) {
327 factory = (PyObject*)pysqlite_CursorType;
328 }
329
330 cursor = PyObject_CallOneArg(factory, (PyObject *)self);
331 if (cursor == NULL)
332 return NULL;
333 if (!PyObject_TypeCheck(cursor, pysqlite_CursorType)) {
334 PyErr_Format(PyExc_TypeError,
335 "factory must return a cursor, not %.100s",
336 Py_TYPE(cursor)->tp_name);
337 Py_DECREF(cursor);
338 return NULL;
339 }
340
341 _pysqlite_drop_unused_cursor_references(self);
342
343 if (cursor && self->row_factory != Py_None) {
344 Py_INCREF(self->row_factory);
345 Py_XSETREF(((pysqlite_Cursor *)cursor)->row_factory, self->row_factory);
346 }
347
348 return cursor;
349 }
350
351 /*[clinic input]
352 _sqlite3.Connection.close as pysqlite_connection_close
353
354 Closes the connection.
355 [clinic start generated code]*/
356
357 static PyObject *
pysqlite_connection_close_impl(pysqlite_Connection * self)358 pysqlite_connection_close_impl(pysqlite_Connection *self)
359 /*[clinic end generated code: output=a546a0da212c9b97 input=3d58064bbffaa3d3]*/
360 {
361 int rc;
362
363 if (!pysqlite_check_thread(self)) {
364 return NULL;
365 }
366
367 if (!self->initialized) {
368 PyErr_SetString(pysqlite_ProgrammingError,
369 "Base Connection.__init__ not called.");
370 return NULL;
371 }
372
373 pysqlite_do_all_statements(self, ACTION_FINALIZE, 1);
374
375 if (self->db) {
376 rc = sqlite3_close_v2(self->db);
377
378 if (rc != SQLITE_OK) {
379 _pysqlite_seterror(self->db, NULL);
380 return NULL;
381 } else {
382 self->db = NULL;
383 }
384 }
385
386 Py_RETURN_NONE;
387 }
388
389 /*
390 * Checks if a connection object is usable (i. e. not closed).
391 *
392 * 0 => error; 1 => ok
393 */
pysqlite_check_connection(pysqlite_Connection * con)394 int pysqlite_check_connection(pysqlite_Connection* con)
395 {
396 if (!con->initialized) {
397 PyErr_SetString(pysqlite_ProgrammingError, "Base Connection.__init__ not called.");
398 return 0;
399 }
400
401 if (!con->db) {
402 PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database.");
403 return 0;
404 } else {
405 return 1;
406 }
407 }
408
_pysqlite_connection_begin(pysqlite_Connection * self)409 PyObject* _pysqlite_connection_begin(pysqlite_Connection* self)
410 {
411 int rc;
412 sqlite3_stmt* statement;
413
414 Py_BEGIN_ALLOW_THREADS
415 rc = sqlite3_prepare_v2(self->db, self->begin_statement, -1, &statement,
416 NULL);
417 Py_END_ALLOW_THREADS
418
419 if (rc != SQLITE_OK) {
420 _pysqlite_seterror(self->db, statement);
421 goto error;
422 }
423
424 rc = pysqlite_step(statement, self);
425 if (rc != SQLITE_DONE) {
426 _pysqlite_seterror(self->db, statement);
427 }
428
429 Py_BEGIN_ALLOW_THREADS
430 rc = sqlite3_finalize(statement);
431 Py_END_ALLOW_THREADS
432
433 if (rc != SQLITE_OK && !PyErr_Occurred()) {
434 _pysqlite_seterror(self->db, NULL);
435 }
436
437 error:
438 if (PyErr_Occurred()) {
439 return NULL;
440 } else {
441 Py_RETURN_NONE;
442 }
443 }
444
445 /*[clinic input]
446 _sqlite3.Connection.commit as pysqlite_connection_commit
447
448 Commit the current transaction.
449 [clinic start generated code]*/
450
451 static PyObject *
pysqlite_connection_commit_impl(pysqlite_Connection * self)452 pysqlite_connection_commit_impl(pysqlite_Connection *self)
453 /*[clinic end generated code: output=3da45579e89407f2 input=39c12c04dda276a8]*/
454 {
455 int rc;
456 sqlite3_stmt* statement;
457
458 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
459 return NULL;
460 }
461
462 if (!sqlite3_get_autocommit(self->db)) {
463
464 Py_BEGIN_ALLOW_THREADS
465 rc = sqlite3_prepare_v2(self->db, "COMMIT", -1, &statement, NULL);
466 Py_END_ALLOW_THREADS
467 if (rc != SQLITE_OK) {
468 _pysqlite_seterror(self->db, NULL);
469 goto error;
470 }
471
472 rc = pysqlite_step(statement, self);
473 if (rc != SQLITE_DONE) {
474 _pysqlite_seterror(self->db, statement);
475 }
476
477 Py_BEGIN_ALLOW_THREADS
478 rc = sqlite3_finalize(statement);
479 Py_END_ALLOW_THREADS
480 if (rc != SQLITE_OK && !PyErr_Occurred()) {
481 _pysqlite_seterror(self->db, NULL);
482 }
483
484 }
485
486 error:
487 if (PyErr_Occurred()) {
488 return NULL;
489 } else {
490 Py_RETURN_NONE;
491 }
492 }
493
494 /*[clinic input]
495 _sqlite3.Connection.rollback as pysqlite_connection_rollback
496
497 Roll back the current transaction.
498 [clinic start generated code]*/
499
500 static PyObject *
pysqlite_connection_rollback_impl(pysqlite_Connection * self)501 pysqlite_connection_rollback_impl(pysqlite_Connection *self)
502 /*[clinic end generated code: output=b66fa0d43e7ef305 input=12d4e8d068942830]*/
503 {
504 int rc;
505 sqlite3_stmt* statement;
506
507 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
508 return NULL;
509 }
510
511 if (!sqlite3_get_autocommit(self->db)) {
512 pysqlite_do_all_statements(self, ACTION_RESET, 1);
513
514 Py_BEGIN_ALLOW_THREADS
515 rc = sqlite3_prepare_v2(self->db, "ROLLBACK", -1, &statement, NULL);
516 Py_END_ALLOW_THREADS
517 if (rc != SQLITE_OK) {
518 _pysqlite_seterror(self->db, NULL);
519 goto error;
520 }
521
522 rc = pysqlite_step(statement, self);
523 if (rc != SQLITE_DONE) {
524 _pysqlite_seterror(self->db, statement);
525 }
526
527 Py_BEGIN_ALLOW_THREADS
528 rc = sqlite3_finalize(statement);
529 Py_END_ALLOW_THREADS
530 if (rc != SQLITE_OK && !PyErr_Occurred()) {
531 _pysqlite_seterror(self->db, NULL);
532 }
533
534 }
535
536 error:
537 if (PyErr_Occurred()) {
538 return NULL;
539 } else {
540 Py_RETURN_NONE;
541 }
542 }
543
544 static int
_pysqlite_set_result(sqlite3_context * context,PyObject * py_val)545 _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)
546 {
547 if (py_val == Py_None) {
548 sqlite3_result_null(context);
549 } else if (PyLong_Check(py_val)) {
550 sqlite_int64 value = _pysqlite_long_as_int64(py_val);
551 if (value == -1 && PyErr_Occurred())
552 return -1;
553 sqlite3_result_int64(context, value);
554 } else if (PyFloat_Check(py_val)) {
555 sqlite3_result_double(context, PyFloat_AsDouble(py_val));
556 } else if (PyUnicode_Check(py_val)) {
557 Py_ssize_t sz;
558 const char *str = PyUnicode_AsUTF8AndSize(py_val, &sz);
559 if (str == NULL) {
560 return -1;
561 }
562 if (sz > INT_MAX) {
563 PyErr_SetString(PyExc_OverflowError,
564 "string is longer than INT_MAX bytes");
565 return -1;
566 }
567 sqlite3_result_text(context, str, (int)sz, SQLITE_TRANSIENT);
568 } else if (PyObject_CheckBuffer(py_val)) {
569 Py_buffer view;
570 if (PyObject_GetBuffer(py_val, &view, PyBUF_SIMPLE) != 0) {
571 PyErr_SetString(PyExc_ValueError,
572 "could not convert BLOB to buffer");
573 return -1;
574 }
575 if (view.len > INT_MAX) {
576 PyErr_SetString(PyExc_OverflowError,
577 "BLOB longer than INT_MAX bytes");
578 PyBuffer_Release(&view);
579 return -1;
580 }
581 sqlite3_result_blob(context, view.buf, (int)view.len, SQLITE_TRANSIENT);
582 PyBuffer_Release(&view);
583 } else {
584 return -1;
585 }
586 return 0;
587 }
588
589 static PyObject *
_pysqlite_build_py_params(sqlite3_context * context,int argc,sqlite3_value ** argv)590 _pysqlite_build_py_params(sqlite3_context *context, int argc,
591 sqlite3_value **argv)
592 {
593 PyObject* args;
594 int i;
595 sqlite3_value* cur_value;
596 PyObject* cur_py_value;
597
598 args = PyTuple_New(argc);
599 if (!args) {
600 return NULL;
601 }
602
603 for (i = 0; i < argc; i++) {
604 cur_value = argv[i];
605 switch (sqlite3_value_type(argv[i])) {
606 case SQLITE_INTEGER:
607 cur_py_value = PyLong_FromLongLong(sqlite3_value_int64(cur_value));
608 break;
609 case SQLITE_FLOAT:
610 cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));
611 break;
612 case SQLITE_TEXT: {
613 sqlite3 *db = sqlite3_context_db_handle(context);
614 const char *text = (const char *)sqlite3_value_text(cur_value);
615
616 if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
617 PyErr_NoMemory();
618 goto error;
619 }
620
621 Py_ssize_t size = sqlite3_value_bytes(cur_value);
622 cur_py_value = PyUnicode_FromStringAndSize(text, size);
623 break;
624 }
625 case SQLITE_BLOB: {
626 sqlite3 *db = sqlite3_context_db_handle(context);
627 const void *blob = sqlite3_value_blob(cur_value);
628
629 if (blob == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {
630 PyErr_NoMemory();
631 goto error;
632 }
633
634 Py_ssize_t size = sqlite3_value_bytes(cur_value);
635 cur_py_value = PyBytes_FromStringAndSize(blob, size);
636 break;
637 }
638 case SQLITE_NULL:
639 default:
640 cur_py_value = Py_NewRef(Py_None);
641 }
642
643 if (!cur_py_value) {
644 goto error;
645 }
646
647 PyTuple_SET_ITEM(args, i, cur_py_value);
648 }
649
650 return args;
651
652 error:
653 Py_DECREF(args);
654 return NULL;
655 }
656
657 static void
_pysqlite_func_callback(sqlite3_context * context,int argc,sqlite3_value ** argv)658 _pysqlite_func_callback(sqlite3_context *context, int argc, sqlite3_value **argv)
659 {
660 PyObject* args;
661 PyObject* py_func;
662 PyObject* py_retval = NULL;
663 int ok;
664
665 PyGILState_STATE threadstate;
666
667 threadstate = PyGILState_Ensure();
668
669 py_func = (PyObject*)sqlite3_user_data(context);
670
671 args = _pysqlite_build_py_params(context, argc, argv);
672 if (args) {
673 py_retval = PyObject_CallObject(py_func, args);
674 Py_DECREF(args);
675 }
676
677 ok = 0;
678 if (py_retval) {
679 ok = _pysqlite_set_result(context, py_retval) == 0;
680 Py_DECREF(py_retval);
681 }
682 if (!ok) {
683 if (_pysqlite_enable_callback_tracebacks) {
684 PyErr_Print();
685 } else {
686 PyErr_Clear();
687 }
688 sqlite3_result_error(context, "user-defined function raised exception", -1);
689 }
690
691 PyGILState_Release(threadstate);
692 }
693
_pysqlite_step_callback(sqlite3_context * context,int argc,sqlite3_value ** params)694 static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params)
695 {
696 PyObject* args;
697 PyObject* function_result = NULL;
698 PyObject* aggregate_class;
699 PyObject** aggregate_instance;
700 PyObject* stepmethod = NULL;
701
702 PyGILState_STATE threadstate;
703
704 threadstate = PyGILState_Ensure();
705
706 aggregate_class = (PyObject*)sqlite3_user_data(context);
707
708 aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
709
710 if (*aggregate_instance == NULL) {
711 *aggregate_instance = _PyObject_CallNoArg(aggregate_class);
712
713 if (PyErr_Occurred()) {
714 *aggregate_instance = 0;
715 if (_pysqlite_enable_callback_tracebacks) {
716 PyErr_Print();
717 } else {
718 PyErr_Clear();
719 }
720 sqlite3_result_error(context, "user-defined aggregate's '__init__' method raised error", -1);
721 goto error;
722 }
723 }
724
725 stepmethod = PyObject_GetAttrString(*aggregate_instance, "step");
726 if (!stepmethod) {
727 goto error;
728 }
729
730 args = _pysqlite_build_py_params(context, argc, params);
731 if (!args) {
732 goto error;
733 }
734
735 function_result = PyObject_CallObject(stepmethod, args);
736 Py_DECREF(args);
737
738 if (!function_result) {
739 if (_pysqlite_enable_callback_tracebacks) {
740 PyErr_Print();
741 } else {
742 PyErr_Clear();
743 }
744 sqlite3_result_error(context, "user-defined aggregate's 'step' method raised error", -1);
745 }
746
747 error:
748 Py_XDECREF(stepmethod);
749 Py_XDECREF(function_result);
750
751 PyGILState_Release(threadstate);
752 }
753
754 static void
_pysqlite_final_callback(sqlite3_context * context)755 _pysqlite_final_callback(sqlite3_context *context)
756 {
757 PyObject* function_result;
758 PyObject** aggregate_instance;
759 _Py_IDENTIFIER(finalize);
760 int ok;
761 PyObject *exception, *value, *tb;
762
763 PyGILState_STATE threadstate;
764
765 threadstate = PyGILState_Ensure();
766
767 aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, 0);
768 if (aggregate_instance == NULL) {
769 /* No rows matched the query; the step handler was never called. */
770 goto error;
771 }
772 else if (!*aggregate_instance) {
773 /* this branch is executed if there was an exception in the aggregate's
774 * __init__ */
775
776 goto error;
777 }
778
779 /* Keep the exception (if any) of the last call to step() */
780 PyErr_Fetch(&exception, &value, &tb);
781
782 function_result = _PyObject_CallMethodIdNoArgs(*aggregate_instance, &PyId_finalize);
783
784 Py_DECREF(*aggregate_instance);
785
786 ok = 0;
787 if (function_result) {
788 ok = _pysqlite_set_result(context, function_result) == 0;
789 Py_DECREF(function_result);
790 }
791 if (!ok) {
792 if (_pysqlite_enable_callback_tracebacks) {
793 PyErr_Print();
794 } else {
795 PyErr_Clear();
796 }
797 sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1);
798 }
799
800 /* Restore the exception (if any) of the last call to step(),
801 but clear also the current exception if finalize() failed */
802 PyErr_Restore(exception, value, tb);
803
804 error:
805 PyGILState_Release(threadstate);
806 }
807
_pysqlite_drop_unused_statement_references(pysqlite_Connection * self)808 static void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self)
809 {
810 PyObject* new_list;
811 PyObject* weakref;
812 int i;
813
814 /* we only need to do this once in a while */
815 if (self->created_statements++ < 200) {
816 return;
817 }
818
819 self->created_statements = 0;
820
821 new_list = PyList_New(0);
822 if (!new_list) {
823 return;
824 }
825
826 for (i = 0; i < PyList_Size(self->statements); i++) {
827 weakref = PyList_GetItem(self->statements, i);
828 if (PyWeakref_GetObject(weakref) != Py_None) {
829 if (PyList_Append(new_list, weakref) != 0) {
830 Py_DECREF(new_list);
831 return;
832 }
833 }
834 }
835
836 Py_SETREF(self->statements, new_list);
837 }
838
_pysqlite_drop_unused_cursor_references(pysqlite_Connection * self)839 static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self)
840 {
841 PyObject* new_list;
842 PyObject* weakref;
843 int i;
844
845 /* we only need to do this once in a while */
846 if (self->created_cursors++ < 200) {
847 return;
848 }
849
850 self->created_cursors = 0;
851
852 new_list = PyList_New(0);
853 if (!new_list) {
854 return;
855 }
856
857 for (i = 0; i < PyList_Size(self->cursors); i++) {
858 weakref = PyList_GetItem(self->cursors, i);
859 if (PyWeakref_GetObject(weakref) != Py_None) {
860 if (PyList_Append(new_list, weakref) != 0) {
861 Py_DECREF(new_list);
862 return;
863 }
864 }
865 }
866
867 Py_SETREF(self->cursors, new_list);
868 }
869
_destructor(void * args)870 static void _destructor(void* args)
871 {
872 // This function may be called without the GIL held, so we need to ensure
873 // that we destroy 'args' with the GIL
874 PyGILState_STATE gstate;
875 gstate = PyGILState_Ensure();
876 Py_DECREF((PyObject*)args);
877 PyGILState_Release(gstate);
878 }
879
880 /*[clinic input]
881 _sqlite3.Connection.create_function as pysqlite_connection_create_function
882
883 name: str
884 narg: int
885 func: object
886 *
887 deterministic: bool = False
888
889 Creates a new function. Non-standard.
890 [clinic start generated code]*/
891
892 static PyObject *
pysqlite_connection_create_function_impl(pysqlite_Connection * self,const char * name,int narg,PyObject * func,int deterministic)893 pysqlite_connection_create_function_impl(pysqlite_Connection *self,
894 const char *name, int narg,
895 PyObject *func, int deterministic)
896 /*[clinic end generated code: output=07d1877dd98c0308 input=f2edcf073e815beb]*/
897 {
898 int rc;
899 int flags = SQLITE_UTF8;
900
901 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
902 return NULL;
903 }
904
905 if (deterministic) {
906 #if SQLITE_VERSION_NUMBER < 3008003
907 PyErr_SetString(pysqlite_NotSupportedError,
908 "deterministic=True requires SQLite 3.8.3 or higher");
909 return NULL;
910 #else
911 if (sqlite3_libversion_number() < 3008003) {
912 PyErr_SetString(pysqlite_NotSupportedError,
913 "deterministic=True requires SQLite 3.8.3 or higher");
914 return NULL;
915 }
916 flags |= SQLITE_DETERMINISTIC;
917 #endif
918 }
919 rc = sqlite3_create_function_v2(self->db,
920 name,
921 narg,
922 flags,
923 (void*)Py_NewRef(func),
924 _pysqlite_func_callback,
925 NULL,
926 NULL,
927 &_destructor); // will decref func
928
929 if (rc != SQLITE_OK) {
930 /* Workaround for SQLite bug: no error code or string is available here */
931 PyErr_SetString(pysqlite_OperationalError, "Error creating function");
932 return NULL;
933 }
934 Py_RETURN_NONE;
935 }
936
937 /*[clinic input]
938 _sqlite3.Connection.create_aggregate as pysqlite_connection_create_aggregate
939
940 name: str
941 n_arg: int
942 aggregate_class: object
943
944 Creates a new aggregate. Non-standard.
945 [clinic start generated code]*/
946
947 static PyObject *
pysqlite_connection_create_aggregate_impl(pysqlite_Connection * self,const char * name,int n_arg,PyObject * aggregate_class)948 pysqlite_connection_create_aggregate_impl(pysqlite_Connection *self,
949 const char *name, int n_arg,
950 PyObject *aggregate_class)
951 /*[clinic end generated code: output=fbb2f858cfa4d8db input=c2e13bbf234500a5]*/
952 {
953 int rc;
954
955 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
956 return NULL;
957 }
958
959 rc = sqlite3_create_function_v2(self->db,
960 name,
961 n_arg,
962 SQLITE_UTF8,
963 (void*)Py_NewRef(aggregate_class),
964 0,
965 &_pysqlite_step_callback,
966 &_pysqlite_final_callback,
967 &_destructor); // will decref func
968 if (rc != SQLITE_OK) {
969 /* Workaround for SQLite bug: no error code or string is available here */
970 PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");
971 return NULL;
972 }
973 Py_RETURN_NONE;
974 }
975
_authorizer_callback(void * user_arg,int action,const char * arg1,const char * arg2,const char * dbname,const char * access_attempt_source)976 static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source)
977 {
978 PyObject *ret;
979 int rc;
980 PyGILState_STATE gilstate;
981
982 gilstate = PyGILState_Ensure();
983
984 ret = PyObject_CallFunction((PyObject*)user_arg, "issss", action, arg1, arg2, dbname, access_attempt_source);
985
986 if (ret == NULL) {
987 if (_pysqlite_enable_callback_tracebacks)
988 PyErr_Print();
989 else
990 PyErr_Clear();
991
992 rc = SQLITE_DENY;
993 }
994 else {
995 if (PyLong_Check(ret)) {
996 rc = _PyLong_AsInt(ret);
997 if (rc == -1 && PyErr_Occurred()) {
998 if (_pysqlite_enable_callback_tracebacks)
999 PyErr_Print();
1000 else
1001 PyErr_Clear();
1002 rc = SQLITE_DENY;
1003 }
1004 }
1005 else {
1006 rc = SQLITE_DENY;
1007 }
1008 Py_DECREF(ret);
1009 }
1010
1011 PyGILState_Release(gilstate);
1012 return rc;
1013 }
1014
_progress_handler(void * user_arg)1015 static int _progress_handler(void* user_arg)
1016 {
1017 int rc;
1018 PyObject *ret;
1019 PyGILState_STATE gilstate;
1020
1021 gilstate = PyGILState_Ensure();
1022 ret = _PyObject_CallNoArg((PyObject*)user_arg);
1023
1024 if (!ret) {
1025 if (_pysqlite_enable_callback_tracebacks) {
1026 PyErr_Print();
1027 } else {
1028 PyErr_Clear();
1029 }
1030
1031 /* abort query if error occurred */
1032 rc = 1;
1033 } else {
1034 rc = (int)PyObject_IsTrue(ret);
1035 Py_DECREF(ret);
1036 }
1037
1038 PyGILState_Release(gilstate);
1039 return rc;
1040 }
1041
1042 #ifdef HAVE_TRACE_V2
1043 /*
1044 * From https://sqlite.org/c3ref/trace_v2.html:
1045 * The integer return value from the callback is currently ignored, though this
1046 * may change in future releases. Callback implementations should return zero
1047 * to ensure future compatibility.
1048 */
_trace_callback(unsigned int type,void * user_arg,void * prepared_statement,void * statement_string)1049 static int _trace_callback(unsigned int type, void* user_arg, void* prepared_statement, void* statement_string)
1050 #else
1051 static void _trace_callback(void* user_arg, const char* statement_string)
1052 #endif
1053 {
1054 PyObject *py_statement = NULL;
1055 PyObject *ret = NULL;
1056
1057 PyGILState_STATE gilstate;
1058
1059 #ifdef HAVE_TRACE_V2
1060 if (type != SQLITE_TRACE_STMT) {
1061 return 0;
1062 }
1063 #endif
1064
1065 gilstate = PyGILState_Ensure();
1066 py_statement = PyUnicode_DecodeUTF8(statement_string,
1067 strlen(statement_string), "replace");
1068 if (py_statement) {
1069 ret = PyObject_CallOneArg((PyObject*)user_arg, py_statement);
1070 Py_DECREF(py_statement);
1071 }
1072
1073 if (ret) {
1074 Py_DECREF(ret);
1075 } else {
1076 if (_pysqlite_enable_callback_tracebacks) {
1077 PyErr_Print();
1078 } else {
1079 PyErr_Clear();
1080 }
1081 }
1082
1083 PyGILState_Release(gilstate);
1084 #ifdef HAVE_TRACE_V2
1085 return 0;
1086 #endif
1087 }
1088
1089 /*[clinic input]
1090 _sqlite3.Connection.set_authorizer as pysqlite_connection_set_authorizer
1091
1092 authorizer_callback as authorizer_cb: object
1093
1094 Sets authorizer callback. Non-standard.
1095 [clinic start generated code]*/
1096
1097 static PyObject *
pysqlite_connection_set_authorizer_impl(pysqlite_Connection * self,PyObject * authorizer_cb)1098 pysqlite_connection_set_authorizer_impl(pysqlite_Connection *self,
1099 PyObject *authorizer_cb)
1100 /*[clinic end generated code: output=f18ba575d788b35c input=df079724c020d2f2]*/
1101 {
1102 int rc;
1103
1104 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1105 return NULL;
1106 }
1107
1108 rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb);
1109 if (rc != SQLITE_OK) {
1110 PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback");
1111 Py_XSETREF(self->function_pinboard_authorizer_cb, NULL);
1112 return NULL;
1113 } else {
1114 Py_INCREF(authorizer_cb);
1115 Py_XSETREF(self->function_pinboard_authorizer_cb, authorizer_cb);
1116 }
1117 Py_RETURN_NONE;
1118 }
1119
1120 /*[clinic input]
1121 _sqlite3.Connection.set_progress_handler as pysqlite_connection_set_progress_handler
1122
1123 progress_handler: object
1124 n: int
1125
1126 Sets progress handler callback. Non-standard.
1127 [clinic start generated code]*/
1128
1129 static PyObject *
pysqlite_connection_set_progress_handler_impl(pysqlite_Connection * self,PyObject * progress_handler,int n)1130 pysqlite_connection_set_progress_handler_impl(pysqlite_Connection *self,
1131 PyObject *progress_handler,
1132 int n)
1133 /*[clinic end generated code: output=35a7c10364cb1b04 input=857696c25f964c64]*/
1134 {
1135 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1136 return NULL;
1137 }
1138
1139 if (progress_handler == Py_None) {
1140 /* None clears the progress handler previously set */
1141 sqlite3_progress_handler(self->db, 0, 0, (void*)0);
1142 Py_XSETREF(self->function_pinboard_progress_handler, NULL);
1143 } else {
1144 sqlite3_progress_handler(self->db, n, _progress_handler, progress_handler);
1145 Py_INCREF(progress_handler);
1146 Py_XSETREF(self->function_pinboard_progress_handler, progress_handler);
1147 }
1148 Py_RETURN_NONE;
1149 }
1150
1151 /*[clinic input]
1152 _sqlite3.Connection.set_trace_callback as pysqlite_connection_set_trace_callback
1153
1154 trace_callback: object
1155
1156 Sets a trace callback called for each SQL statement (passed as unicode).
1157
1158 Non-standard.
1159 [clinic start generated code]*/
1160
1161 static PyObject *
pysqlite_connection_set_trace_callback_impl(pysqlite_Connection * self,PyObject * trace_callback)1162 pysqlite_connection_set_trace_callback_impl(pysqlite_Connection *self,
1163 PyObject *trace_callback)
1164 /*[clinic end generated code: output=fb0e307b9924d454 input=56d60fd38d763679]*/
1165 {
1166 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1167 return NULL;
1168 }
1169
1170 if (trace_callback == Py_None) {
1171 /*
1172 * None clears the trace callback previously set
1173 *
1174 * Ref.
1175 * - https://sqlite.org/c3ref/c_trace.html
1176 * - https://sqlite.org/c3ref/trace_v2.html
1177 */
1178 #ifdef HAVE_TRACE_V2
1179 sqlite3_trace_v2(self->db, SQLITE_TRACE_STMT, 0, 0);
1180 #else
1181 sqlite3_trace(self->db, 0, (void*)0);
1182 #endif
1183 Py_XSETREF(self->function_pinboard_trace_callback, NULL);
1184 } else {
1185 #ifdef HAVE_TRACE_V2
1186 sqlite3_trace_v2(self->db, SQLITE_TRACE_STMT, _trace_callback, trace_callback);
1187 #else
1188 sqlite3_trace(self->db, _trace_callback, trace_callback);
1189 #endif
1190 Py_INCREF(trace_callback);
1191 Py_XSETREF(self->function_pinboard_trace_callback, trace_callback);
1192 }
1193
1194 Py_RETURN_NONE;
1195 }
1196
1197 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1198 /*[clinic input]
1199 _sqlite3.Connection.enable_load_extension as pysqlite_connection_enable_load_extension
1200
1201 enable as onoff: bool(accept={int})
1202 /
1203
1204 Enable dynamic loading of SQLite extension modules. Non-standard.
1205 [clinic start generated code]*/
1206
1207 static PyObject *
pysqlite_connection_enable_load_extension_impl(pysqlite_Connection * self,int onoff)1208 pysqlite_connection_enable_load_extension_impl(pysqlite_Connection *self,
1209 int onoff)
1210 /*[clinic end generated code: output=9cac37190d388baf input=5c0da5b121121cbc]*/
1211 {
1212 int rc;
1213
1214 if (PySys_Audit("sqlite3.enable_load_extension",
1215 "OO", self, onoff ? Py_True : Py_False) < 0) {
1216 return NULL;
1217 }
1218
1219 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1220 return NULL;
1221 }
1222
1223 rc = sqlite3_enable_load_extension(self->db, onoff);
1224
1225 if (rc != SQLITE_OK) {
1226 PyErr_SetString(pysqlite_OperationalError, "Error enabling load extension");
1227 return NULL;
1228 } else {
1229 Py_RETURN_NONE;
1230 }
1231 }
1232
1233 /*[clinic input]
1234 _sqlite3.Connection.load_extension as pysqlite_connection_load_extension
1235
1236 name as extension_name: str
1237 /
1238
1239 Load SQLite extension module. Non-standard.
1240 [clinic start generated code]*/
1241
1242 static PyObject *
pysqlite_connection_load_extension_impl(pysqlite_Connection * self,const char * extension_name)1243 pysqlite_connection_load_extension_impl(pysqlite_Connection *self,
1244 const char *extension_name)
1245 /*[clinic end generated code: output=47eb1d7312bc97a7 input=0b711574560db9fc]*/
1246 {
1247 int rc;
1248 char* errmsg;
1249
1250 if (PySys_Audit("sqlite3.load_extension", "Os", self, extension_name) < 0) {
1251 return NULL;
1252 }
1253
1254 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1255 return NULL;
1256 }
1257
1258 rc = sqlite3_load_extension(self->db, extension_name, 0, &errmsg);
1259 if (rc != 0) {
1260 PyErr_SetString(pysqlite_OperationalError, errmsg);
1261 return NULL;
1262 } else {
1263 Py_RETURN_NONE;
1264 }
1265 }
1266 #endif
1267
pysqlite_check_thread(pysqlite_Connection * self)1268 int pysqlite_check_thread(pysqlite_Connection* self)
1269 {
1270 if (self->check_same_thread) {
1271 if (PyThread_get_thread_ident() != self->thread_ident) {
1272 PyErr_Format(pysqlite_ProgrammingError,
1273 "SQLite objects created in a thread can only be used in that same thread. "
1274 "The object was created in thread id %lu and this is thread id %lu.",
1275 self->thread_ident, PyThread_get_thread_ident());
1276 return 0;
1277 }
1278
1279 }
1280 return 1;
1281 }
1282
pysqlite_connection_get_isolation_level(pysqlite_Connection * self,void * unused)1283 static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)
1284 {
1285 if (!pysqlite_check_connection(self)) {
1286 return NULL;
1287 }
1288 return Py_NewRef(self->isolation_level);
1289 }
1290
pysqlite_connection_get_total_changes(pysqlite_Connection * self,void * unused)1291 static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)
1292 {
1293 if (!pysqlite_check_connection(self)) {
1294 return NULL;
1295 } else {
1296 return Py_BuildValue("i", sqlite3_total_changes(self->db));
1297 }
1298 }
1299
pysqlite_connection_get_in_transaction(pysqlite_Connection * self,void * unused)1300 static PyObject* pysqlite_connection_get_in_transaction(pysqlite_Connection* self, void* unused)
1301 {
1302 if (!pysqlite_check_connection(self)) {
1303 return NULL;
1304 }
1305 if (!sqlite3_get_autocommit(self->db)) {
1306 Py_RETURN_TRUE;
1307 }
1308 Py_RETURN_FALSE;
1309 }
1310
1311 static int
pysqlite_connection_set_isolation_level(pysqlite_Connection * self,PyObject * isolation_level,void * Py_UNUSED (ignored))1312 pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level, void *Py_UNUSED(ignored))
1313 {
1314 if (isolation_level == NULL) {
1315 PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
1316 return -1;
1317 }
1318 if (isolation_level == Py_None) {
1319 /* We might get called during connection init, so we cannot use
1320 * pysqlite_connection_commit() here. */
1321 if (self->db && !sqlite3_get_autocommit(self->db)) {
1322 int rc;
1323 Py_BEGIN_ALLOW_THREADS
1324 rc = sqlite3_exec(self->db, "COMMIT", NULL, NULL, NULL);
1325 Py_END_ALLOW_THREADS
1326 if (rc != SQLITE_OK) {
1327 return _pysqlite_seterror(self->db, NULL);
1328 }
1329 }
1330
1331 self->begin_statement = NULL;
1332 } else {
1333 const char * const *candidate;
1334 PyObject *uppercase_level;
1335 _Py_IDENTIFIER(upper);
1336
1337 if (!PyUnicode_Check(isolation_level)) {
1338 PyErr_Format(PyExc_TypeError,
1339 "isolation_level must be a string or None, not %.100s",
1340 Py_TYPE(isolation_level)->tp_name);
1341 return -1;
1342 }
1343
1344 uppercase_level = _PyObject_CallMethodIdOneArg(
1345 (PyObject *)&PyUnicode_Type, &PyId_upper,
1346 isolation_level);
1347 if (!uppercase_level) {
1348 return -1;
1349 }
1350 for (candidate = begin_statements; *candidate; candidate++) {
1351 if (_PyUnicode_EqualToASCIIString(uppercase_level, *candidate + 6))
1352 break;
1353 }
1354 Py_DECREF(uppercase_level);
1355 if (!*candidate) {
1356 PyErr_SetString(PyExc_ValueError,
1357 "invalid value for isolation_level");
1358 return -1;
1359 }
1360 self->begin_statement = *candidate;
1361 }
1362
1363 Py_INCREF(isolation_level);
1364 Py_XSETREF(self->isolation_level, isolation_level);
1365 return 0;
1366 }
1367
1368 static PyObject *
pysqlite_connection_call(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)1369 pysqlite_connection_call(pysqlite_Connection *self, PyObject *args,
1370 PyObject *kwargs)
1371 {
1372 PyObject* sql;
1373 pysqlite_Statement* statement;
1374 PyObject* weakref;
1375
1376 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1377 return NULL;
1378 }
1379
1380 if (!_PyArg_NoKeywords(MODULE_NAME ".Connection", kwargs))
1381 return NULL;
1382
1383 if (!PyArg_ParseTuple(args, "U", &sql))
1384 return NULL;
1385
1386 _pysqlite_drop_unused_statement_references(self);
1387
1388 statement = pysqlite_statement_create(self, sql);
1389 if (statement == NULL) {
1390 return NULL;
1391 }
1392
1393 weakref = PyWeakref_NewRef((PyObject*)statement, NULL);
1394 if (weakref == NULL)
1395 goto error;
1396 if (PyList_Append(self->statements, weakref) != 0) {
1397 Py_DECREF(weakref);
1398 goto error;
1399 }
1400 Py_DECREF(weakref);
1401
1402 return (PyObject*)statement;
1403
1404 error:
1405 Py_DECREF(statement);
1406 return NULL;
1407 }
1408
1409 /*[clinic input]
1410 _sqlite3.Connection.execute as pysqlite_connection_execute
1411
1412 sql: unicode
1413 parameters: object = NULL
1414 /
1415
1416 Executes a SQL statement. Non-standard.
1417 [clinic start generated code]*/
1418
1419 static PyObject *
pysqlite_connection_execute_impl(pysqlite_Connection * self,PyObject * sql,PyObject * parameters)1420 pysqlite_connection_execute_impl(pysqlite_Connection *self, PyObject *sql,
1421 PyObject *parameters)
1422 /*[clinic end generated code: output=5be05ae01ee17ee4 input=fbd17c75c7140271]*/
1423 {
1424 _Py_IDENTIFIER(execute);
1425 PyObject* cursor = 0;
1426 PyObject* result = 0;
1427
1428 cursor = _PyObject_CallMethodIdNoArgs((PyObject*)self, &PyId_cursor);
1429 if (!cursor) {
1430 goto error;
1431 }
1432
1433 result = _PyObject_CallMethodIdObjArgs(cursor, &PyId_execute, sql, parameters, NULL);
1434 if (!result) {
1435 Py_CLEAR(cursor);
1436 }
1437
1438 error:
1439 Py_XDECREF(result);
1440
1441 return cursor;
1442 }
1443
1444 /*[clinic input]
1445 _sqlite3.Connection.executemany as pysqlite_connection_executemany
1446
1447 sql: unicode
1448 parameters: object
1449 /
1450
1451 Repeatedly executes a SQL statement. Non-standard.
1452 [clinic start generated code]*/
1453
1454 static PyObject *
pysqlite_connection_executemany_impl(pysqlite_Connection * self,PyObject * sql,PyObject * parameters)1455 pysqlite_connection_executemany_impl(pysqlite_Connection *self,
1456 PyObject *sql, PyObject *parameters)
1457 /*[clinic end generated code: output=776cd2fd20bfe71f input=4feab80659ffc82b]*/
1458 {
1459 _Py_IDENTIFIER(executemany);
1460 PyObject* cursor = 0;
1461 PyObject* result = 0;
1462
1463 cursor = _PyObject_CallMethodIdNoArgs((PyObject*)self, &PyId_cursor);
1464 if (!cursor) {
1465 goto error;
1466 }
1467
1468 result = _PyObject_CallMethodIdObjArgs(cursor, &PyId_executemany, sql,
1469 parameters, NULL);
1470 if (!result) {
1471 Py_CLEAR(cursor);
1472 }
1473
1474 error:
1475 Py_XDECREF(result);
1476
1477 return cursor;
1478 }
1479
1480 /*[clinic input]
1481 _sqlite3.Connection.executescript as pysqlite_connection_executescript
1482
1483 sql_script as script_obj: object
1484 /
1485
1486 Executes multiple SQL statements at once. Non-standard.
1487 [clinic start generated code]*/
1488
1489 static PyObject *
pysqlite_connection_executescript(pysqlite_Connection * self,PyObject * script_obj)1490 pysqlite_connection_executescript(pysqlite_Connection *self,
1491 PyObject *script_obj)
1492 /*[clinic end generated code: output=4c4f9d77aa0ae37d input=b27ae5c24ffb8b43]*/
1493 {
1494 _Py_IDENTIFIER(executescript);
1495 PyObject* cursor = 0;
1496 PyObject* result = 0;
1497
1498 cursor = _PyObject_CallMethodIdNoArgs((PyObject*)self, &PyId_cursor);
1499 if (!cursor) {
1500 goto error;
1501 }
1502
1503 result = _PyObject_CallMethodIdObjArgs(cursor, &PyId_executescript,
1504 script_obj, NULL);
1505 if (!result) {
1506 Py_CLEAR(cursor);
1507 }
1508
1509 error:
1510 Py_XDECREF(result);
1511
1512 return cursor;
1513 }
1514
1515 /* ------------------------- COLLATION CODE ------------------------ */
1516
1517 static int
pysqlite_collation_callback(void * context,int text1_length,const void * text1_data,int text2_length,const void * text2_data)1518 pysqlite_collation_callback(
1519 void* context,
1520 int text1_length, const void* text1_data,
1521 int text2_length, const void* text2_data)
1522 {
1523 PyObject* callback = (PyObject*)context;
1524 PyObject* string1 = 0;
1525 PyObject* string2 = 0;
1526 PyGILState_STATE gilstate;
1527 PyObject* retval = NULL;
1528 long longval;
1529 int result = 0;
1530 gilstate = PyGILState_Ensure();
1531
1532 if (PyErr_Occurred()) {
1533 goto finally;
1534 }
1535
1536 string1 = PyUnicode_FromStringAndSize((const char*)text1_data, text1_length);
1537 string2 = PyUnicode_FromStringAndSize((const char*)text2_data, text2_length);
1538
1539 if (!string1 || !string2) {
1540 goto finally; /* failed to allocate strings */
1541 }
1542
1543 retval = PyObject_CallFunctionObjArgs(callback, string1, string2, NULL);
1544
1545 if (!retval) {
1546 /* execution failed */
1547 goto finally;
1548 }
1549
1550 longval = PyLong_AsLongAndOverflow(retval, &result);
1551 if (longval == -1 && PyErr_Occurred()) {
1552 PyErr_Clear();
1553 result = 0;
1554 }
1555 else if (!result) {
1556 if (longval > 0)
1557 result = 1;
1558 else if (longval < 0)
1559 result = -1;
1560 }
1561
1562 finally:
1563 Py_XDECREF(string1);
1564 Py_XDECREF(string2);
1565 Py_XDECREF(retval);
1566 PyGILState_Release(gilstate);
1567 return result;
1568 }
1569
1570 /*[clinic input]
1571 _sqlite3.Connection.interrupt as pysqlite_connection_interrupt
1572
1573 Abort any pending database operation. Non-standard.
1574 [clinic start generated code]*/
1575
1576 static PyObject *
pysqlite_connection_interrupt_impl(pysqlite_Connection * self)1577 pysqlite_connection_interrupt_impl(pysqlite_Connection *self)
1578 /*[clinic end generated code: output=f193204bc9e70b47 input=4bd0ad083cf93aa7]*/
1579 {
1580 PyObject* retval = NULL;
1581
1582 if (!pysqlite_check_connection(self)) {
1583 goto finally;
1584 }
1585
1586 sqlite3_interrupt(self->db);
1587
1588 retval = Py_NewRef(Py_None);
1589
1590 finally:
1591 return retval;
1592 }
1593
1594 /* Function author: Paul Kippes <kippesp@gmail.com>
1595 * Class method of Connection to call the Python function _iterdump
1596 * of the sqlite3 module.
1597 */
1598 /*[clinic input]
1599 _sqlite3.Connection.iterdump as pysqlite_connection_iterdump
1600
1601 Returns iterator to the dump of the database in an SQL text format.
1602
1603 Non-standard.
1604 [clinic start generated code]*/
1605
1606 static PyObject *
pysqlite_connection_iterdump_impl(pysqlite_Connection * self)1607 pysqlite_connection_iterdump_impl(pysqlite_Connection *self)
1608 /*[clinic end generated code: output=586997aaf9808768 input=53bc907cb5eedb85]*/
1609 {
1610 _Py_IDENTIFIER(_iterdump);
1611 PyObject* retval = NULL;
1612 PyObject* module = NULL;
1613 PyObject* module_dict;
1614 PyObject* pyfn_iterdump;
1615
1616 if (!pysqlite_check_connection(self)) {
1617 goto finally;
1618 }
1619
1620 module = PyImport_ImportModule(MODULE_NAME ".dump");
1621 if (!module) {
1622 goto finally;
1623 }
1624
1625 module_dict = PyModule_GetDict(module);
1626 if (!module_dict) {
1627 goto finally;
1628 }
1629
1630 pyfn_iterdump = _PyDict_GetItemIdWithError(module_dict, &PyId__iterdump);
1631 if (!pyfn_iterdump) {
1632 if (!PyErr_Occurred()) {
1633 PyErr_SetString(pysqlite_OperationalError,
1634 "Failed to obtain _iterdump() reference");
1635 }
1636 goto finally;
1637 }
1638
1639 retval = PyObject_CallOneArg(pyfn_iterdump, (PyObject *)self);
1640
1641 finally:
1642 Py_XDECREF(module);
1643 return retval;
1644 }
1645
1646 /*[clinic input]
1647 _sqlite3.Connection.backup as pysqlite_connection_backup
1648
1649 target: object(type='pysqlite_Connection *', subclass_of='pysqlite_ConnectionType')
1650 *
1651 pages: int = -1
1652 progress: object = None
1653 name: str = "main"
1654 sleep: double = 0.250
1655
1656 Makes a backup of the database. Non-standard.
1657 [clinic start generated code]*/
1658
1659 static PyObject *
pysqlite_connection_backup_impl(pysqlite_Connection * self,pysqlite_Connection * target,int pages,PyObject * progress,const char * name,double sleep)1660 pysqlite_connection_backup_impl(pysqlite_Connection *self,
1661 pysqlite_Connection *target, int pages,
1662 PyObject *progress, const char *name,
1663 double sleep)
1664 /*[clinic end generated code: output=306a3e6a38c36334 input=30ae45fc420bfd3b]*/
1665 {
1666 int rc;
1667 int sleep_ms = (int)(sleep * 1000.0);
1668 sqlite3 *bck_conn;
1669 sqlite3_backup *bck_handle;
1670
1671 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1672 return NULL;
1673 }
1674
1675 if (!pysqlite_check_connection(target)) {
1676 return NULL;
1677 }
1678
1679 if (target == self) {
1680 PyErr_SetString(PyExc_ValueError, "target cannot be the same connection instance");
1681 return NULL;
1682 }
1683
1684 #if SQLITE_VERSION_NUMBER < 3008008
1685 /* Since 3.8.8 this is already done, per commit
1686 https://www.sqlite.org/src/info/169b5505498c0a7e */
1687 if (!sqlite3_get_autocommit(target->db)) {
1688 PyErr_SetString(pysqlite_OperationalError, "target is in transaction");
1689 return NULL;
1690 }
1691 #endif
1692
1693 if (progress != Py_None && !PyCallable_Check(progress)) {
1694 PyErr_SetString(PyExc_TypeError, "progress argument must be a callable");
1695 return NULL;
1696 }
1697
1698 if (pages == 0) {
1699 pages = -1;
1700 }
1701
1702 bck_conn = target->db;
1703
1704 Py_BEGIN_ALLOW_THREADS
1705 bck_handle = sqlite3_backup_init(bck_conn, "main", self->db, name);
1706 Py_END_ALLOW_THREADS
1707
1708 if (bck_handle == NULL) {
1709 _pysqlite_seterror(bck_conn, NULL);
1710 return NULL;
1711 }
1712
1713 do {
1714 Py_BEGIN_ALLOW_THREADS
1715 rc = sqlite3_backup_step(bck_handle, pages);
1716 Py_END_ALLOW_THREADS
1717
1718 if (progress != Py_None) {
1719 int remaining = sqlite3_backup_remaining(bck_handle);
1720 int pagecount = sqlite3_backup_pagecount(bck_handle);
1721 PyObject *res = PyObject_CallFunction(progress, "iii", rc,
1722 remaining, pagecount);
1723 if (res == NULL) {
1724 /* Callback failed: abort backup and bail. */
1725 Py_BEGIN_ALLOW_THREADS
1726 sqlite3_backup_finish(bck_handle);
1727 Py_END_ALLOW_THREADS
1728 return NULL;
1729 }
1730 Py_DECREF(res);
1731 }
1732
1733 /* Sleep for a while if there are still further pages to copy and
1734 the engine could not make any progress */
1735 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED) {
1736 Py_BEGIN_ALLOW_THREADS
1737 sqlite3_sleep(sleep_ms);
1738 Py_END_ALLOW_THREADS
1739 }
1740 } while (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED);
1741
1742 Py_BEGIN_ALLOW_THREADS
1743 rc = sqlite3_backup_finish(bck_handle);
1744 Py_END_ALLOW_THREADS
1745
1746 if (rc != SQLITE_OK) {
1747 _pysqlite_seterror(bck_conn, NULL);
1748 return NULL;
1749 }
1750
1751 Py_RETURN_NONE;
1752 }
1753
1754 /*[clinic input]
1755 _sqlite3.Connection.create_collation as pysqlite_connection_create_collation
1756
1757 name: unicode
1758 callback as callable: object
1759 /
1760
1761 Creates a collation function. Non-standard.
1762 [clinic start generated code]*/
1763
1764 static PyObject *
pysqlite_connection_create_collation_impl(pysqlite_Connection * self,PyObject * name,PyObject * callable)1765 pysqlite_connection_create_collation_impl(pysqlite_Connection *self,
1766 PyObject *name, PyObject *callable)
1767 /*[clinic end generated code: output=0f63b8995565ae22 input=5c3898813a776cf2]*/
1768 {
1769 PyObject* uppercase_name = 0;
1770 Py_ssize_t i, len;
1771 _Py_IDENTIFIER(upper);
1772 const char *uppercase_name_str;
1773 int rc;
1774 unsigned int kind;
1775 const void *data;
1776
1777 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1778 goto finally;
1779 }
1780
1781 uppercase_name = _PyObject_CallMethodIdOneArg((PyObject *)&PyUnicode_Type,
1782 &PyId_upper, name);
1783 if (!uppercase_name) {
1784 goto finally;
1785 }
1786
1787 if (PyUnicode_READY(uppercase_name))
1788 goto finally;
1789 len = PyUnicode_GET_LENGTH(uppercase_name);
1790 kind = PyUnicode_KIND(uppercase_name);
1791 data = PyUnicode_DATA(uppercase_name);
1792 for (i=0; i<len; i++) {
1793 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
1794 if ((ch >= '0' && ch <= '9')
1795 || (ch >= 'A' && ch <= 'Z')
1796 || (ch == '_'))
1797 {
1798 continue;
1799 } else {
1800 PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name");
1801 goto finally;
1802 }
1803 }
1804
1805 uppercase_name_str = PyUnicode_AsUTF8(uppercase_name);
1806 if (!uppercase_name_str)
1807 goto finally;
1808
1809 if (callable != Py_None && !PyCallable_Check(callable)) {
1810 PyErr_SetString(PyExc_TypeError, "parameter must be callable");
1811 goto finally;
1812 }
1813
1814 if (callable != Py_None) {
1815 if (PyDict_SetItem(self->collations, uppercase_name, callable) == -1)
1816 goto finally;
1817 } else {
1818 if (PyDict_DelItem(self->collations, uppercase_name) == -1)
1819 goto finally;
1820 }
1821
1822 rc = sqlite3_create_collation(self->db,
1823 uppercase_name_str,
1824 SQLITE_UTF8,
1825 (callable != Py_None) ? callable : NULL,
1826 (callable != Py_None) ? pysqlite_collation_callback : NULL);
1827 if (rc != SQLITE_OK) {
1828 if (callable != Py_None) {
1829 if (PyDict_DelItem(self->collations, uppercase_name) < 0) {
1830 PyErr_Clear();
1831 }
1832 }
1833 _pysqlite_seterror(self->db, NULL);
1834 goto finally;
1835 }
1836
1837 finally:
1838 Py_XDECREF(uppercase_name);
1839
1840 if (PyErr_Occurred()) {
1841 return NULL;
1842 }
1843 return Py_NewRef(Py_None);
1844 }
1845
1846 /*[clinic input]
1847 _sqlite3.Connection.__enter__ as pysqlite_connection_enter
1848
1849 Called when the connection is used as a context manager.
1850
1851 Returns itself as a convenience to the caller.
1852 [clinic start generated code]*/
1853
1854 static PyObject *
pysqlite_connection_enter_impl(pysqlite_Connection * self)1855 pysqlite_connection_enter_impl(pysqlite_Connection *self)
1856 /*[clinic end generated code: output=457b09726d3e9dcd input=127d7a4f17e86d8f]*/
1857 {
1858 return Py_NewRef((PyObject *)self);
1859 }
1860
1861 /*[clinic input]
1862 _sqlite3.Connection.__exit__ as pysqlite_connection_exit
1863
1864 type as exc_type: object
1865 value as exc_value: object
1866 traceback as exc_tb: object
1867 /
1868
1869 Called when the connection is used as a context manager.
1870
1871 If there was any exception, a rollback takes place; otherwise we commit.
1872 [clinic start generated code]*/
1873
1874 static PyObject *
pysqlite_connection_exit_impl(pysqlite_Connection * self,PyObject * exc_type,PyObject * exc_value,PyObject * exc_tb)1875 pysqlite_connection_exit_impl(pysqlite_Connection *self, PyObject *exc_type,
1876 PyObject *exc_value, PyObject *exc_tb)
1877 /*[clinic end generated code: output=0705200e9321202a input=bd66f1532c9c54a7]*/
1878 {
1879 int commit = 0;
1880 PyObject* result;
1881
1882 if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
1883 commit = 1;
1884 result = pysqlite_connection_commit_impl(self);
1885 }
1886 else {
1887 result = pysqlite_connection_rollback_impl(self);
1888 }
1889
1890 if (result == NULL) {
1891 if (commit) {
1892 /* Commit failed; try to rollback in order to unlock the database.
1893 * If rollback also fails, chain the exceptions. */
1894 PyObject *exc, *val, *tb;
1895 PyErr_Fetch(&exc, &val, &tb);
1896 result = pysqlite_connection_rollback_impl(self);
1897 if (result == NULL) {
1898 _PyErr_ChainExceptions(exc, val, tb);
1899 }
1900 else {
1901 Py_DECREF(result);
1902 PyErr_Restore(exc, val, tb);
1903 }
1904 }
1905 return NULL;
1906 }
1907 Py_DECREF(result);
1908
1909 Py_RETURN_FALSE;
1910 }
1911
1912 static const char connection_doc[] =
1913 PyDoc_STR("SQLite database connection object.");
1914
1915 static PyGetSetDef connection_getset[] = {
1916 {"isolation_level", (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
1917 {"total_changes", (getter)pysqlite_connection_get_total_changes, (setter)0},
1918 {"in_transaction", (getter)pysqlite_connection_get_in_transaction, (setter)0},
1919 {NULL}
1920 };
1921
1922 static PyMethodDef connection_methods[] = {
1923 PYSQLITE_CONNECTION_BACKUP_METHODDEF
1924 PYSQLITE_CONNECTION_CLOSE_METHODDEF
1925 PYSQLITE_CONNECTION_COMMIT_METHODDEF
1926 PYSQLITE_CONNECTION_CREATE_AGGREGATE_METHODDEF
1927 PYSQLITE_CONNECTION_CREATE_COLLATION_METHODDEF
1928 PYSQLITE_CONNECTION_CREATE_FUNCTION_METHODDEF
1929 PYSQLITE_CONNECTION_CURSOR_METHODDEF
1930 PYSQLITE_CONNECTION_ENABLE_LOAD_EXTENSION_METHODDEF
1931 PYSQLITE_CONNECTION_ENTER_METHODDEF
1932 PYSQLITE_CONNECTION_EXECUTEMANY_METHODDEF
1933 PYSQLITE_CONNECTION_EXECUTESCRIPT_METHODDEF
1934 PYSQLITE_CONNECTION_EXECUTE_METHODDEF
1935 PYSQLITE_CONNECTION_EXIT_METHODDEF
1936 PYSQLITE_CONNECTION_INTERRUPT_METHODDEF
1937 PYSQLITE_CONNECTION_ITERDUMP_METHODDEF
1938 PYSQLITE_CONNECTION_LOAD_EXTENSION_METHODDEF
1939 PYSQLITE_CONNECTION_ROLLBACK_METHODDEF
1940 PYSQLITE_CONNECTION_SET_AUTHORIZER_METHODDEF
1941 PYSQLITE_CONNECTION_SET_PROGRESS_HANDLER_METHODDEF
1942 PYSQLITE_CONNECTION_SET_TRACE_CALLBACK_METHODDEF
1943 {NULL, NULL}
1944 };
1945
1946 static struct PyMemberDef connection_members[] =
1947 {
1948 {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), READONLY},
1949 {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), READONLY},
1950 {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), READONLY},
1951 {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), READONLY},
1952 {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), READONLY},
1953 {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), READONLY},
1954 {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), READONLY},
1955 {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), READONLY},
1956 {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), READONLY},
1957 {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), READONLY},
1958 {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)},
1959 {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)},
1960 {NULL}
1961 };
1962
1963 static PyType_Slot connection_slots[] = {
1964 {Py_tp_dealloc, connection_dealloc},
1965 {Py_tp_doc, (void *)connection_doc},
1966 {Py_tp_methods, connection_methods},
1967 {Py_tp_members, connection_members},
1968 {Py_tp_getset, connection_getset},
1969 {Py_tp_init, pysqlite_connection_init},
1970 {Py_tp_call, pysqlite_connection_call},
1971 {Py_tp_traverse, connection_traverse},
1972 {Py_tp_clear, connection_clear},
1973 {0, NULL},
1974 };
1975
1976 static PyType_Spec connection_spec = {
1977 .name = MODULE_NAME ".Connection",
1978 .basicsize = sizeof(pysqlite_Connection),
1979 .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
1980 Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
1981 .slots = connection_slots,
1982 };
1983
1984 PyTypeObject *pysqlite_ConnectionType = NULL;
1985
1986 int
pysqlite_connection_setup_types(PyObject * module)1987 pysqlite_connection_setup_types(PyObject *module)
1988 {
1989 pysqlite_ConnectionType = (PyTypeObject *)PyType_FromModuleAndSpec(module, &connection_spec, NULL);
1990 if (pysqlite_ConnectionType == NULL) {
1991 return -1;
1992 }
1993 return 0;
1994 }
1995