1 /* connection.c - the connection type
2 *
3 * Copyright (C) 2004-2010 Gerhard H�ring <[email protected]>
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 "connection.h"
27 #include "statement.h"
28 #include "cursor.h"
29 #include "prepare_protocol.h"
30 #include "util.h"
31 #include "sqlitecompat.h"
32
33 #include "pythread.h"
34
35 #define ACTION_FINALIZE 1
36 #define ACTION_RESET 2
37
38 #if SQLITE_VERSION_NUMBER >= 3003008
39 #ifndef SQLITE_OMIT_LOAD_EXTENSION
40 #define HAVE_LOAD_EXTENSION
41 #endif
42 #endif
43
44 static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level);
45 static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self);
46
47
_sqlite3_result_error(sqlite3_context * ctx,const char * errmsg,int len)48 static void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len)
49 {
50 /* in older SQLite versions, calling sqlite3_result_error in callbacks
51 * triggers a bug in SQLite that leads either to irritating results or
52 * segfaults, depending on the SQLite version */
53 #if SQLITE_VERSION_NUMBER >= 3003003
54 sqlite3_result_error(ctx, errmsg, len);
55 #else
56 PyErr_SetString(pysqlite_OperationalError, errmsg);
57 #endif
58 }
59
pysqlite_connection_init(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)60 int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
61 {
62 static char *kwlist[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", NULL, NULL};
63
64 PyObject* database;
65 int detect_types = 0;
66 PyObject* isolation_level = NULL;
67 PyObject* factory = NULL;
68 int check_same_thread = 1;
69 int cached_statements = 100;
70 double timeout = 5.0;
71 int rc;
72 PyObject* class_attr = NULL;
73 PyObject* class_attr_str = NULL;
74 int is_apsw_connection = 0;
75 PyObject* database_utf8;
76
77 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|diOiOi", kwlist,
78 &database, &timeout, &detect_types, &isolation_level, &check_same_thread, &factory, &cached_statements))
79 {
80 return -1;
81 }
82
83 self->initialized = 1;
84
85 self->begin_statement = NULL;
86
87 self->statement_cache = NULL;
88 self->statements = NULL;
89 self->cursors = NULL;
90
91 Py_INCREF(Py_None);
92 self->row_factory = Py_None;
93
94 Py_INCREF(&PyUnicode_Type);
95 self->text_factory = (PyObject*)&PyUnicode_Type;
96
97 if (PyString_Check(database) || PyUnicode_Check(database)) {
98 if (PyString_Check(database)) {
99 database_utf8 = database;
100 Py_INCREF(database_utf8);
101 } else {
102 database_utf8 = PyUnicode_AsUTF8String(database);
103 if (!database_utf8) {
104 return -1;
105 }
106 }
107
108 Py_BEGIN_ALLOW_THREADS
109 rc = sqlite3_open(PyString_AsString(database_utf8), &self->db);
110 Py_END_ALLOW_THREADS
111
112 Py_DECREF(database_utf8);
113
114 if (rc != SQLITE_OK) {
115 _pysqlite_seterror(self->db, NULL);
116 return -1;
117 }
118 } else {
119 /* Create a pysqlite connection from an APSW connection */
120 class_attr = PyObject_GetAttrString(database, "__class__");
121 if (class_attr) {
122 class_attr_str = PyObject_Str(class_attr);
123 if (class_attr_str) {
124 if (strcmp(PyString_AsString(class_attr_str), "<type 'apsw.Connection'>") == 0) {
125 /* In the APSW Connection object, the first entry after
126 * PyObject_HEAD is the sqlite3* we want to get hold of.
127 * Luckily, this is the same layout as we have in our
128 * pysqlite_Connection */
129 self->db = ((pysqlite_Connection*)database)->db;
130
131 Py_INCREF(database);
132 self->apsw_connection = database;
133 is_apsw_connection = 1;
134 }
135 }
136 }
137 Py_XDECREF(class_attr_str);
138 Py_XDECREF(class_attr);
139
140 if (!is_apsw_connection) {
141 PyErr_SetString(PyExc_ValueError, "database parameter must be string or APSW Connection object");
142 return -1;
143 }
144 }
145
146 if (!isolation_level) {
147 isolation_level = PyString_FromString("");
148 if (!isolation_level) {
149 return -1;
150 }
151 } else {
152 Py_INCREF(isolation_level);
153 }
154 self->isolation_level = NULL;
155 if (pysqlite_connection_set_isolation_level(self, isolation_level) < 0) {
156 Py_DECREF(isolation_level);
157 return -1;
158 }
159 Py_DECREF(isolation_level);
160
161 self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements);
162 if (PyErr_Occurred()) {
163 return -1;
164 }
165
166 self->created_statements = 0;
167 self->created_cursors = 0;
168
169 /* Create lists of weak references to statements/cursors */
170 self->statements = PyList_New(0);
171 self->cursors = PyList_New(0);
172 if (!self->statements || !self->cursors) {
173 return -1;
174 }
175
176 /* By default, the Cache class INCREFs the factory in its initializer, and
177 * decrefs it in its deallocator method. Since this would create a circular
178 * reference here, we're breaking it by decrementing self, and telling the
179 * cache class to not decref the factory (self) in its deallocator.
180 */
181 self->statement_cache->decref_factory = 0;
182 Py_DECREF(self);
183
184 self->inTransaction = 0;
185 self->detect_types = detect_types;
186 self->timeout = timeout;
187 (void)sqlite3_busy_timeout(self->db, (int)(timeout*1000));
188 #ifdef WITH_THREAD
189 self->thread_ident = PyThread_get_thread_ident();
190 #endif
191 self->check_same_thread = check_same_thread;
192
193 self->function_pinboard = PyDict_New();
194 if (!self->function_pinboard) {
195 return -1;
196 }
197
198 self->collations = PyDict_New();
199 if (!self->collations) {
200 return -1;
201 }
202
203 self->Warning = pysqlite_Warning;
204 self->Error = pysqlite_Error;
205 self->InterfaceError = pysqlite_InterfaceError;
206 self->DatabaseError = pysqlite_DatabaseError;
207 self->DataError = pysqlite_DataError;
208 self->OperationalError = pysqlite_OperationalError;
209 self->IntegrityError = pysqlite_IntegrityError;
210 self->InternalError = pysqlite_InternalError;
211 self->ProgrammingError = pysqlite_ProgrammingError;
212 self->NotSupportedError = pysqlite_NotSupportedError;
213
214 return 0;
215 }
216
217 /* Empty the entire statement cache of this connection */
pysqlite_flush_statement_cache(pysqlite_Connection * self)218 void pysqlite_flush_statement_cache(pysqlite_Connection* self)
219 {
220 pysqlite_Node* node;
221 pysqlite_Statement* statement;
222
223 node = self->statement_cache->first;
224
225 while (node) {
226 statement = (pysqlite_Statement*)(node->data);
227 (void)pysqlite_statement_finalize(statement);
228 node = node->next;
229 }
230
231 Py_SETREF(self->statement_cache,
232 (pysqlite_Cache *)PyObject_CallFunction((PyObject *)&pysqlite_CacheType, "O", self));
233 Py_DECREF(self);
234 self->statement_cache->decref_factory = 0;
235 }
236
237 /* action in (ACTION_RESET, ACTION_FINALIZE) */
pysqlite_do_all_statements(pysqlite_Connection * self,int action,int reset_cursors)238 void pysqlite_do_all_statements(pysqlite_Connection* self, int action, int reset_cursors)
239 {
240 int i;
241 PyObject* weakref;
242 PyObject* statement;
243 pysqlite_Cursor* cursor;
244
245 for (i = 0; i < PyList_Size(self->statements); i++) {
246 weakref = PyList_GetItem(self->statements, i);
247 statement = PyWeakref_GetObject(weakref);
248 if (statement != Py_None) {
249 if (action == ACTION_RESET) {
250 (void)pysqlite_statement_reset((pysqlite_Statement*)statement);
251 } else {
252 (void)pysqlite_statement_finalize((pysqlite_Statement*)statement);
253 }
254 }
255 }
256
257 if (reset_cursors) {
258 for (i = 0; i < PyList_Size(self->cursors); i++) {
259 weakref = PyList_GetItem(self->cursors, i);
260 cursor = (pysqlite_Cursor*)PyWeakref_GetObject(weakref);
261 if ((PyObject*)cursor != Py_None) {
262 cursor->reset = 1;
263 }
264 }
265 }
266 }
267
pysqlite_connection_dealloc(pysqlite_Connection * self)268 void pysqlite_connection_dealloc(pysqlite_Connection* self)
269 {
270 PyObject* ret = NULL;
271
272 Py_XDECREF(self->statement_cache);
273
274 /* Clean up if user has not called .close() explicitly. */
275 if (self->db) {
276 Py_BEGIN_ALLOW_THREADS
277 sqlite3_close(self->db);
278 Py_END_ALLOW_THREADS
279 } else if (self->apsw_connection) {
280 ret = PyObject_CallMethod(self->apsw_connection, "close", "");
281 Py_XDECREF(ret);
282 Py_XDECREF(self->apsw_connection);
283 }
284
285 if (self->begin_statement) {
286 PyMem_Free(self->begin_statement);
287 }
288 Py_XDECREF(self->isolation_level);
289 Py_XDECREF(self->function_pinboard);
290 Py_XDECREF(self->row_factory);
291 Py_XDECREF(self->text_factory);
292 Py_XDECREF(self->collations);
293 Py_XDECREF(self->statements);
294 Py_XDECREF(self->cursors);
295
296 Py_TYPE(self)->tp_free((PyObject*)self);
297 }
298
299 /*
300 * Registers a cursor with the connection.
301 *
302 * 0 => error; 1 => ok
303 */
pysqlite_connection_register_cursor(pysqlite_Connection * connection,PyObject * cursor)304 int pysqlite_connection_register_cursor(pysqlite_Connection* connection, PyObject* cursor)
305 {
306 PyObject* weakref;
307
308 weakref = PyWeakref_NewRef((PyObject*)cursor, NULL);
309 if (!weakref) {
310 goto error;
311 }
312
313 if (PyList_Append(connection->cursors, weakref) != 0) {
314 Py_CLEAR(weakref);
315 goto error;
316 }
317
318 Py_DECREF(weakref);
319
320 return 1;
321 error:
322 return 0;
323 }
324
pysqlite_connection_cursor(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)325 PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
326 {
327 static char *kwlist[] = {"factory", NULL};
328 PyObject* factory = NULL;
329 PyObject* cursor;
330
331 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist,
332 &factory)) {
333 return NULL;
334 }
335
336 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
337 return NULL;
338 }
339
340 if (factory == NULL) {
341 factory = (PyObject*)&pysqlite_CursorType;
342 }
343
344 cursor = PyObject_CallFunctionObjArgs(factory, (PyObject *)self, NULL);
345 if (cursor == NULL)
346 return NULL;
347 if (!PyObject_TypeCheck(cursor, &pysqlite_CursorType)) {
348 PyErr_Format(PyExc_TypeError,
349 "factory must return a cursor, not %.100s",
350 Py_TYPE(cursor)->tp_name);
351 Py_DECREF(cursor);
352 return NULL;
353 }
354
355 _pysqlite_drop_unused_cursor_references(self);
356
357 if (cursor && self->row_factory != Py_None) {
358 Py_INCREF(self->row_factory);
359 Py_XSETREF(((pysqlite_Cursor *)cursor)->row_factory, self->row_factory);
360 }
361
362 return cursor;
363 }
364
pysqlite_connection_close(pysqlite_Connection * self,PyObject * args)365 PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args)
366 {
367 PyObject* ret;
368 int rc;
369
370 if (!pysqlite_check_thread(self)) {
371 return NULL;
372 }
373
374 pysqlite_do_all_statements(self, ACTION_FINALIZE, 1);
375
376 if (self->db) {
377 if (self->apsw_connection) {
378 ret = PyObject_CallMethod(self->apsw_connection, "close", "");
379 Py_XDECREF(ret);
380 Py_CLEAR(self->apsw_connection);
381 self->db = NULL;
382 } else {
383 Py_BEGIN_ALLOW_THREADS
384 rc = sqlite3_close(self->db);
385 Py_END_ALLOW_THREADS
386
387 if (rc != SQLITE_OK) {
388 _pysqlite_seterror(self->db, NULL);
389 return NULL;
390 } else {
391 self->db = NULL;
392 }
393 }
394 }
395
396 Py_INCREF(Py_None);
397 return Py_None;
398 }
399
400 /*
401 * Checks if a connection object is usable (i. e. not closed).
402 *
403 * 0 => error; 1 => ok
404 */
pysqlite_check_connection(pysqlite_Connection * con)405 int pysqlite_check_connection(pysqlite_Connection* con)
406 {
407 if (!con->initialized) {
408 PyErr_SetString(pysqlite_ProgrammingError, "Base Connection.__init__ not called.");
409 return 0;
410 }
411
412 if (!con->db) {
413 PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database.");
414 return 0;
415 } else {
416 return 1;
417 }
418 }
419
_pysqlite_connection_begin(pysqlite_Connection * self)420 PyObject* _pysqlite_connection_begin(pysqlite_Connection* self)
421 {
422 int rc;
423 const char* tail;
424 sqlite3_stmt* statement;
425
426 Py_BEGIN_ALLOW_THREADS
427 rc = sqlite3_prepare(self->db, self->begin_statement, -1, &statement, &tail);
428 Py_END_ALLOW_THREADS
429
430 if (rc != SQLITE_OK) {
431 _pysqlite_seterror(self->db, statement);
432 goto error;
433 }
434
435 rc = pysqlite_step(statement, self);
436 if (rc == SQLITE_DONE) {
437 self->inTransaction = 1;
438 } else {
439 _pysqlite_seterror(self->db, statement);
440 }
441
442 Py_BEGIN_ALLOW_THREADS
443 rc = sqlite3_finalize(statement);
444 Py_END_ALLOW_THREADS
445
446 if (rc != SQLITE_OK && !PyErr_Occurred()) {
447 _pysqlite_seterror(self->db, NULL);
448 }
449
450 error:
451 if (PyErr_Occurred()) {
452 return NULL;
453 } else {
454 Py_INCREF(Py_None);
455 return Py_None;
456 }
457 }
458
pysqlite_connection_commit(pysqlite_Connection * self,PyObject * args)459 PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args)
460 {
461 int rc;
462 const char* tail;
463 sqlite3_stmt* statement;
464
465 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
466 return NULL;
467 }
468
469 if (self->inTransaction) {
470
471 Py_BEGIN_ALLOW_THREADS
472 rc = sqlite3_prepare(self->db, "COMMIT", -1, &statement, &tail);
473 Py_END_ALLOW_THREADS
474 if (rc != SQLITE_OK) {
475 _pysqlite_seterror(self->db, NULL);
476 goto error;
477 }
478
479 rc = pysqlite_step(statement, self);
480 if (rc == SQLITE_DONE) {
481 self->inTransaction = 0;
482 } else {
483 _pysqlite_seterror(self->db, statement);
484 }
485
486 Py_BEGIN_ALLOW_THREADS
487 rc = sqlite3_finalize(statement);
488 Py_END_ALLOW_THREADS
489 if (rc != SQLITE_OK && !PyErr_Occurred()) {
490 _pysqlite_seterror(self->db, NULL);
491 }
492
493 }
494
495 error:
496 if (PyErr_Occurred()) {
497 return NULL;
498 } else {
499 Py_INCREF(Py_None);
500 return Py_None;
501 }
502 }
503
pysqlite_connection_rollback(pysqlite_Connection * self,PyObject * args)504 PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args)
505 {
506 int rc;
507 const char* tail;
508 sqlite3_stmt* statement;
509
510 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
511 return NULL;
512 }
513
514 if (self->inTransaction) {
515 pysqlite_do_all_statements(self, ACTION_RESET, 1);
516
517 Py_BEGIN_ALLOW_THREADS
518 rc = sqlite3_prepare(self->db, "ROLLBACK", -1, &statement, &tail);
519 Py_END_ALLOW_THREADS
520 if (rc != SQLITE_OK) {
521 _pysqlite_seterror(self->db, NULL);
522 goto error;
523 }
524
525 rc = pysqlite_step(statement, self);
526 if (rc == SQLITE_DONE) {
527 self->inTransaction = 0;
528 } else {
529 _pysqlite_seterror(self->db, statement);
530 }
531
532 Py_BEGIN_ALLOW_THREADS
533 rc = sqlite3_finalize(statement);
534 Py_END_ALLOW_THREADS
535 if (rc != SQLITE_OK && !PyErr_Occurred()) {
536 _pysqlite_seterror(self->db, NULL);
537 }
538
539 }
540
541 error:
542 if (PyErr_Occurred()) {
543 return NULL;
544 } else {
545 Py_INCREF(Py_None);
546 return Py_None;
547 }
548 }
549
550 static int
_pysqlite_set_result(sqlite3_context * context,PyObject * py_val)551 _pysqlite_set_result(sqlite3_context* context, PyObject* py_val)
552 {
553 if (py_val == Py_None) {
554 sqlite3_result_null(context);
555 } else if (PyInt_Check(py_val)) {
556 sqlite3_result_int64(context, (sqlite_int64)PyInt_AsLong(py_val));
557 } else if (PyLong_Check(py_val)) {
558 sqlite_int64 value = _pysqlite_long_as_int64(py_val);
559 if (value == -1 && PyErr_Occurred())
560 return -1;
561 sqlite3_result_int64(context, value);
562 } else if (PyFloat_Check(py_val)) {
563 sqlite3_result_double(context, PyFloat_AsDouble(py_val));
564 } else if (PyBuffer_Check(py_val)) {
565 const char* buffer;
566 Py_ssize_t buflen;
567 if (PyObject_AsCharBuffer(py_val, &buffer, &buflen) != 0) {
568 PyErr_SetString(PyExc_ValueError, "could not convert BLOB to buffer");
569 return -1;
570 }
571 sqlite3_result_blob(context, buffer, buflen, SQLITE_TRANSIENT);
572 } else if (PyString_Check(py_val)) {
573 sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT);
574 } else if (PyUnicode_Check(py_val)) {
575 PyObject * stringval = PyUnicode_AsUTF8String(py_val);
576 if (!stringval)
577 return -1;
578 sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT);
579 Py_DECREF(stringval);
580 } else {
581 return -1;
582 }
583 return 0;
584 }
585
_pysqlite_build_py_params(sqlite3_context * context,int argc,sqlite3_value ** argv)586 PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv)
587 {
588 PyObject* args;
589 int i;
590 sqlite3_value* cur_value;
591 PyObject* cur_py_value;
592 const char* val_str;
593 Py_ssize_t buflen;
594 void* raw_buffer;
595
596 args = PyTuple_New(argc);
597 if (!args) {
598 return NULL;
599 }
600
601 for (i = 0; i < argc; i++) {
602 cur_value = argv[i];
603 switch (sqlite3_value_type(argv[i])) {
604 case SQLITE_INTEGER:
605 cur_py_value = _pysqlite_long_from_int64(sqlite3_value_int64(cur_value));
606 break;
607 case SQLITE_FLOAT:
608 cur_py_value = PyFloat_FromDouble(sqlite3_value_double(cur_value));
609 break;
610 case SQLITE_TEXT:
611 val_str = (const char*)sqlite3_value_text(cur_value);
612 cur_py_value = PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
613 /* TODO: have a way to show errors here */
614 if (!cur_py_value) {
615 PyErr_Clear();
616 Py_INCREF(Py_None);
617 cur_py_value = Py_None;
618 }
619 break;
620 case SQLITE_BLOB:
621 buflen = sqlite3_value_bytes(cur_value);
622 cur_py_value = PyBuffer_New(buflen);
623 if (!cur_py_value) {
624 break;
625 }
626 if (PyObject_AsWriteBuffer(cur_py_value, &raw_buffer, &buflen)) {
627 Py_DECREF(cur_py_value);
628 cur_py_value = NULL;
629 break;
630 }
631 memcpy(raw_buffer, sqlite3_value_blob(cur_value), buflen);
632 break;
633 case SQLITE_NULL:
634 default:
635 Py_INCREF(Py_None);
636 cur_py_value = Py_None;
637 }
638
639 if (!cur_py_value) {
640 Py_DECREF(args);
641 return NULL;
642 }
643
644 PyTuple_SetItem(args, i, cur_py_value);
645
646 }
647
648 return args;
649 }
650
_pysqlite_func_callback(sqlite3_context * context,int argc,sqlite3_value ** argv)651 void _pysqlite_func_callback(sqlite3_context* context, int argc, sqlite3_value** argv)
652 {
653 PyObject* args;
654 PyObject* py_func;
655 PyObject* py_retval = NULL;
656 int ok;
657
658 #ifdef WITH_THREAD
659 PyGILState_STATE threadstate;
660
661 threadstate = PyGILState_Ensure();
662 #endif
663
664 py_func = (PyObject*)sqlite3_user_data(context);
665
666 args = _pysqlite_build_py_params(context, argc, argv);
667 if (args) {
668 py_retval = PyObject_CallObject(py_func, args);
669 Py_DECREF(args);
670 }
671
672 ok = 0;
673 if (py_retval) {
674 ok = _pysqlite_set_result(context, py_retval) == 0;
675 Py_DECREF(py_retval);
676 }
677 if (!ok) {
678 if (_pysqlite_enable_callback_tracebacks) {
679 PyErr_Print();
680 } else {
681 PyErr_Clear();
682 }
683 _sqlite3_result_error(context, "user-defined function raised exception", -1);
684 }
685
686 #ifdef WITH_THREAD
687 PyGILState_Release(threadstate);
688 #endif
689 }
690
_pysqlite_step_callback(sqlite3_context * context,int argc,sqlite3_value ** params)691 static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params)
692 {
693 PyObject* args;
694 PyObject* function_result = NULL;
695 PyObject* aggregate_class;
696 PyObject** aggregate_instance;
697 PyObject* stepmethod = NULL;
698
699 #ifdef WITH_THREAD
700 PyGILState_STATE threadstate;
701
702 threadstate = PyGILState_Ensure();
703 #endif
704
705 aggregate_class = (PyObject*)sqlite3_user_data(context);
706
707 aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
708
709 if (*aggregate_instance == 0) {
710 *aggregate_instance = PyObject_CallFunction(aggregate_class, "");
711
712 if (PyErr_Occurred()) {
713 *aggregate_instance = 0;
714 if (_pysqlite_enable_callback_tracebacks) {
715 PyErr_Print();
716 } else {
717 PyErr_Clear();
718 }
719 _sqlite3_result_error(context, "user-defined aggregate's '__init__' method raised error", -1);
720 goto error;
721 }
722 }
723
724 stepmethod = PyObject_GetAttrString(*aggregate_instance, "step");
725 if (!stepmethod) {
726 goto error;
727 }
728
729 args = _pysqlite_build_py_params(context, argc, params);
730 if (!args) {
731 goto error;
732 }
733
734 function_result = PyObject_CallObject(stepmethod, args);
735 Py_DECREF(args);
736
737 if (!function_result) {
738 if (_pysqlite_enable_callback_tracebacks) {
739 PyErr_Print();
740 } else {
741 PyErr_Clear();
742 }
743 _sqlite3_result_error(context, "user-defined aggregate's 'step' method raised error", -1);
744 }
745
746 error:
747 Py_XDECREF(stepmethod);
748 Py_XDECREF(function_result);
749
750 #ifdef WITH_THREAD
751 PyGILState_Release(threadstate);
752 #endif
753 }
754
_pysqlite_final_callback(sqlite3_context * context)755 void _pysqlite_final_callback(sqlite3_context* context)
756 {
757 PyObject* function_result;
758 PyObject** aggregate_instance;
759 int ok;
760
761 #ifdef WITH_THREAD
762 PyGILState_STATE threadstate;
763
764 threadstate = PyGILState_Ensure();
765 #endif
766
767 aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, sizeof(PyObject*));
768 if (!*aggregate_instance) {
769 /* this branch is executed if there was an exception in the aggregate's
770 * __init__ */
771
772 goto error;
773 }
774
775 function_result = PyObject_CallMethod(*aggregate_instance, "finalize", "");
776 Py_DECREF(*aggregate_instance);
777
778 ok = 0;
779 if (function_result) {
780 ok = _pysqlite_set_result(context, function_result) == 0;
781 Py_DECREF(function_result);
782 }
783 if (!ok) {
784 if (_pysqlite_enable_callback_tracebacks) {
785 PyErr_Print();
786 } else {
787 PyErr_Clear();
788 }
789 _sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1);
790 }
791
792 error:
793 ; /* necessary for --without-threads flag */
794 #ifdef WITH_THREAD
795 PyGILState_Release(threadstate);
796 #endif
797 }
798
_pysqlite_drop_unused_statement_references(pysqlite_Connection * self)799 static void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self)
800 {
801 PyObject* new_list;
802 PyObject* weakref;
803 int i;
804
805 /* we only need to do this once in a while */
806 if (self->created_statements++ < 200) {
807 return;
808 }
809
810 self->created_statements = 0;
811
812 new_list = PyList_New(0);
813 if (!new_list) {
814 return;
815 }
816
817 for (i = 0; i < PyList_Size(self->statements); i++) {
818 weakref = PyList_GetItem(self->statements, i);
819 if (PyWeakref_GetObject(weakref) != Py_None) {
820 if (PyList_Append(new_list, weakref) != 0) {
821 Py_DECREF(new_list);
822 return;
823 }
824 }
825 }
826
827 Py_SETREF(self->statements, new_list);
828 }
829
_pysqlite_drop_unused_cursor_references(pysqlite_Connection * self)830 static void _pysqlite_drop_unused_cursor_references(pysqlite_Connection* self)
831 {
832 PyObject* new_list;
833 PyObject* weakref;
834 int i;
835
836 /* we only need to do this once in a while */
837 if (self->created_cursors++ < 200) {
838 return;
839 }
840
841 self->created_cursors = 0;
842
843 new_list = PyList_New(0);
844 if (!new_list) {
845 return;
846 }
847
848 for (i = 0; i < PyList_Size(self->cursors); i++) {
849 weakref = PyList_GetItem(self->cursors, i);
850 if (PyWeakref_GetObject(weakref) != Py_None) {
851 if (PyList_Append(new_list, weakref) != 0) {
852 Py_DECREF(new_list);
853 return;
854 }
855 }
856 }
857
858 Py_SETREF(self->cursors, new_list);
859 }
860
pysqlite_connection_create_function(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)861 PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
862 {
863 static char *kwlist[] = {"name", "narg", "func", NULL, NULL};
864
865 PyObject* func;
866 char* name;
867 int narg;
868 int rc;
869
870 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
871 return NULL;
872 }
873
874 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO", kwlist,
875 &name, &narg, &func))
876 {
877 return NULL;
878 }
879
880 rc = sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _pysqlite_func_callback, NULL, NULL);
881
882 if (rc != SQLITE_OK) {
883 /* Workaround for SQLite bug: no error code or string is available here */
884 PyErr_SetString(pysqlite_OperationalError, "Error creating function");
885 return NULL;
886 } else {
887 if (PyDict_SetItem(self->function_pinboard, func, Py_None) == -1)
888 return NULL;
889
890 Py_INCREF(Py_None);
891 return Py_None;
892 }
893 }
894
pysqlite_connection_create_aggregate(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)895 PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
896 {
897 PyObject* aggregate_class;
898
899 int n_arg;
900 char* name;
901 static char *kwlist[] = { "name", "n_arg", "aggregate_class", NULL };
902 int rc;
903
904 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
905 return NULL;
906 }
907
908 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO:create_aggregate",
909 kwlist, &name, &n_arg, &aggregate_class)) {
910 return NULL;
911 }
912
913 rc = sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_pysqlite_step_callback, &_pysqlite_final_callback);
914 if (rc != SQLITE_OK) {
915 /* Workaround for SQLite bug: no error code or string is available here */
916 PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate");
917 return NULL;
918 } else {
919 if (PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None) == -1)
920 return NULL;
921
922 Py_INCREF(Py_None);
923 return Py_None;
924 }
925 }
926
_authorizer_callback(void * user_arg,int action,const char * arg1,const char * arg2,const char * dbname,const char * access_attempt_source)927 static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source)
928 {
929 PyObject *ret;
930 int rc;
931 #ifdef WITH_THREAD
932 PyGILState_STATE gilstate;
933
934 gilstate = PyGILState_Ensure();
935 #endif
936 ret = PyObject_CallFunction((PyObject*)user_arg, "issss", action, arg1, arg2, dbname, access_attempt_source);
937
938 if (!ret) {
939 if (_pysqlite_enable_callback_tracebacks) {
940 PyErr_Print();
941 } else {
942 PyErr_Clear();
943 }
944
945 rc = SQLITE_DENY;
946 } else {
947 if (PyInt_Check(ret)) {
948 rc = _PyInt_AsInt(ret);
949 if (rc == -1 && PyErr_Occurred())
950 rc = SQLITE_DENY;
951 } else {
952 rc = SQLITE_DENY;
953 }
954 Py_DECREF(ret);
955 }
956
957 #ifdef WITH_THREAD
958 PyGILState_Release(gilstate);
959 #endif
960 return rc;
961 }
962
_progress_handler(void * user_arg)963 static int _progress_handler(void* user_arg)
964 {
965 int rc;
966 PyObject *ret;
967 #ifdef WITH_THREAD
968 PyGILState_STATE gilstate;
969
970 gilstate = PyGILState_Ensure();
971 #endif
972 ret = PyObject_CallFunction((PyObject*)user_arg, "");
973
974 if (!ret) {
975 if (_pysqlite_enable_callback_tracebacks) {
976 PyErr_Print();
977 } else {
978 PyErr_Clear();
979 }
980
981 /* abort query if error occurred */
982 rc = 1;
983 } else {
984 rc = (int)PyObject_IsTrue(ret);
985 Py_DECREF(ret);
986 }
987
988 #ifdef WITH_THREAD
989 PyGILState_Release(gilstate);
990 #endif
991 return rc;
992 }
993
pysqlite_connection_set_authorizer(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)994 static PyObject* pysqlite_connection_set_authorizer(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
995 {
996 PyObject* authorizer_cb;
997
998 static char *kwlist[] = { "authorizer_callback", NULL };
999 int rc;
1000
1001 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1002 return NULL;
1003 }
1004
1005 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_authorizer",
1006 kwlist, &authorizer_cb)) {
1007 return NULL;
1008 }
1009
1010 rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb);
1011
1012 if (rc != SQLITE_OK) {
1013 PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback");
1014 return NULL;
1015 } else {
1016 if (PyDict_SetItem(self->function_pinboard, authorizer_cb, Py_None) == -1)
1017 return NULL;
1018
1019 Py_INCREF(Py_None);
1020 return Py_None;
1021 }
1022 }
1023
pysqlite_connection_set_progress_handler(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)1024 static PyObject* pysqlite_connection_set_progress_handler(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
1025 {
1026 PyObject* progress_handler;
1027 int n;
1028
1029 static char *kwlist[] = { "progress_handler", "n", NULL };
1030
1031 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1032 return NULL;
1033 }
1034
1035 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi:set_progress_handler",
1036 kwlist, &progress_handler, &n)) {
1037 return NULL;
1038 }
1039
1040 if (progress_handler == Py_None) {
1041 /* None clears the progress handler previously set */
1042 sqlite3_progress_handler(self->db, 0, 0, (void*)0);
1043 } else {
1044 sqlite3_progress_handler(self->db, n, _progress_handler, progress_handler);
1045 if (PyDict_SetItem(self->function_pinboard, progress_handler, Py_None) == -1)
1046 return NULL;
1047 }
1048
1049 Py_INCREF(Py_None);
1050 return Py_None;
1051 }
1052
1053 #ifdef HAVE_LOAD_EXTENSION
pysqlite_enable_load_extension(pysqlite_Connection * self,PyObject * args)1054 static PyObject* pysqlite_enable_load_extension(pysqlite_Connection* self, PyObject* args)
1055 {
1056 int rc;
1057 int onoff;
1058
1059 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1060 return NULL;
1061 }
1062
1063 if (!PyArg_ParseTuple(args, "i", &onoff)) {
1064 return NULL;
1065 }
1066
1067 rc = sqlite3_enable_load_extension(self->db, onoff);
1068
1069 if (rc != SQLITE_OK) {
1070 PyErr_SetString(pysqlite_OperationalError, "Error enabling load extension");
1071 return NULL;
1072 } else {
1073 Py_INCREF(Py_None);
1074 return Py_None;
1075 }
1076 }
1077
pysqlite_load_extension(pysqlite_Connection * self,PyObject * args)1078 static PyObject* pysqlite_load_extension(pysqlite_Connection* self, PyObject* args)
1079 {
1080 int rc;
1081 char* extension_name;
1082 char* errmsg;
1083
1084 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1085 return NULL;
1086 }
1087
1088 if (!PyArg_ParseTuple(args, "s", &extension_name)) {
1089 return NULL;
1090 }
1091
1092 rc = sqlite3_load_extension(self->db, extension_name, 0, &errmsg);
1093 if (rc != 0) {
1094 PyErr_SetString(pysqlite_OperationalError, errmsg);
1095 return NULL;
1096 } else {
1097 Py_INCREF(Py_None);
1098 return Py_None;
1099 }
1100 }
1101 #endif
1102
pysqlite_check_thread(pysqlite_Connection * self)1103 int pysqlite_check_thread(pysqlite_Connection* self)
1104 {
1105 #ifdef WITH_THREAD
1106 if (self->check_same_thread) {
1107 if (PyThread_get_thread_ident() != self->thread_ident) {
1108 PyErr_Format(pysqlite_ProgrammingError,
1109 "SQLite objects created in a thread can only be used in that same thread. "
1110 "The object was created in thread id %ld and this is thread id %ld.",
1111 self->thread_ident, PyThread_get_thread_ident());
1112 return 0;
1113 }
1114
1115 }
1116 #endif
1117 return 1;
1118 }
1119
pysqlite_connection_get_isolation_level(pysqlite_Connection * self,void * unused)1120 static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused)
1121 {
1122 Py_INCREF(self->isolation_level);
1123 return self->isolation_level;
1124 }
1125
pysqlite_connection_get_total_changes(pysqlite_Connection * self,void * unused)1126 static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused)
1127 {
1128 if (!pysqlite_check_connection(self)) {
1129 return NULL;
1130 } else {
1131 return Py_BuildValue("i", sqlite3_total_changes(self->db));
1132 }
1133 }
1134
pysqlite_connection_set_isolation_level(pysqlite_Connection * self,PyObject * isolation_level)1135 static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level)
1136 {
1137 PyObject* res;
1138 PyObject* begin_statement;
1139 char* begin_statement_str;
1140
1141 Py_XDECREF(self->isolation_level);
1142
1143 if (self->begin_statement) {
1144 PyMem_Free(self->begin_statement);
1145 self->begin_statement = NULL;
1146 }
1147
1148 if (isolation_level == Py_None) {
1149 Py_INCREF(Py_None);
1150 self->isolation_level = Py_None;
1151
1152 res = pysqlite_connection_commit(self, NULL);
1153 if (!res) {
1154 return -1;
1155 }
1156 Py_DECREF(res);
1157
1158 self->inTransaction = 0;
1159 } else {
1160 Py_INCREF(isolation_level);
1161 self->isolation_level = isolation_level;
1162
1163 begin_statement = PyString_FromString("BEGIN ");
1164 if (!begin_statement) {
1165 return -1;
1166 }
1167 PyString_Concat(&begin_statement, isolation_level);
1168 if (!begin_statement) {
1169 return -1;
1170 }
1171
1172 begin_statement_str = PyString_AsString(begin_statement);
1173 if (!begin_statement_str) {
1174 Py_DECREF(begin_statement);
1175 return -1;
1176 }
1177 self->begin_statement = PyMem_Malloc(strlen(begin_statement_str) + 2);
1178 if (!self->begin_statement) {
1179 Py_DECREF(begin_statement);
1180 return -1;
1181 }
1182
1183 strcpy(self->begin_statement, begin_statement_str);
1184 Py_DECREF(begin_statement);
1185 }
1186
1187 return 0;
1188 }
1189
pysqlite_connection_call(pysqlite_Connection * self,PyObject * args,PyObject * kwargs)1190 PyObject* pysqlite_connection_call(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
1191 {
1192 PyObject* sql;
1193 pysqlite_Statement* statement;
1194 PyObject* weakref;
1195 int rc;
1196
1197 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1198 return NULL;
1199 }
1200
1201 if (!_PyArg_NoKeywords(MODULE_NAME ".Connection()", kwargs))
1202 return NULL;
1203
1204 if (!PyArg_ParseTuple(args, "O", &sql)) {
1205 return NULL;
1206 }
1207
1208 _pysqlite_drop_unused_statement_references(self);
1209
1210 statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType);
1211 if (!statement) {
1212 return NULL;
1213 }
1214
1215 statement->db = NULL;
1216 statement->st = NULL;
1217 statement->sql = NULL;
1218 statement->in_use = 0;
1219 statement->in_weakreflist = NULL;
1220
1221 rc = pysqlite_statement_create(statement, self, sql);
1222
1223 if (rc != SQLITE_OK) {
1224 if (rc == PYSQLITE_TOO_MUCH_SQL) {
1225 PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time.");
1226 } else if (rc == PYSQLITE_SQL_WRONG_TYPE) {
1227 if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError))
1228 PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string or unicode.");
1229 } else {
1230 (void)pysqlite_statement_reset(statement);
1231 _pysqlite_seterror(self->db, NULL);
1232 }
1233
1234 Py_CLEAR(statement);
1235 } else {
1236 weakref = PyWeakref_NewRef((PyObject*)statement, NULL);
1237 if (!weakref) {
1238 Py_CLEAR(statement);
1239 goto error;
1240 }
1241
1242 if (PyList_Append(self->statements, weakref) != 0) {
1243 Py_CLEAR(weakref);
1244 goto error;
1245 }
1246
1247 Py_DECREF(weakref);
1248 }
1249
1250 error:
1251 return (PyObject*)statement;
1252 }
1253
pysqlite_connection_execute(pysqlite_Connection * self,PyObject * args)1254 PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args)
1255 {
1256 PyObject* cursor = 0;
1257 PyObject* result = 0;
1258 PyObject* method = 0;
1259
1260 cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
1261 if (!cursor) {
1262 goto error;
1263 }
1264
1265 method = PyObject_GetAttrString(cursor, "execute");
1266 if (!method) {
1267 Py_CLEAR(cursor);
1268 goto error;
1269 }
1270
1271 result = PyObject_CallObject(method, args);
1272 if (!result) {
1273 Py_CLEAR(cursor);
1274 }
1275
1276 error:
1277 Py_XDECREF(result);
1278 Py_XDECREF(method);
1279
1280 return cursor;
1281 }
1282
pysqlite_connection_executemany(pysqlite_Connection * self,PyObject * args)1283 PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args)
1284 {
1285 PyObject* cursor = 0;
1286 PyObject* result = 0;
1287 PyObject* method = 0;
1288
1289 cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
1290 if (!cursor) {
1291 goto error;
1292 }
1293
1294 method = PyObject_GetAttrString(cursor, "executemany");
1295 if (!method) {
1296 Py_CLEAR(cursor);
1297 goto error;
1298 }
1299
1300 result = PyObject_CallObject(method, args);
1301 if (!result) {
1302 Py_CLEAR(cursor);
1303 }
1304
1305 error:
1306 Py_XDECREF(result);
1307 Py_XDECREF(method);
1308
1309 return cursor;
1310 }
1311
pysqlite_connection_executescript(pysqlite_Connection * self,PyObject * args)1312 PyObject* pysqlite_connection_executescript(pysqlite_Connection* self, PyObject* args)
1313 {
1314 PyObject* cursor = 0;
1315 PyObject* result = 0;
1316 PyObject* method = 0;
1317
1318 cursor = PyObject_CallMethod((PyObject*)self, "cursor", "");
1319 if (!cursor) {
1320 goto error;
1321 }
1322
1323 method = PyObject_GetAttrString(cursor, "executescript");
1324 if (!method) {
1325 Py_CLEAR(cursor);
1326 goto error;
1327 }
1328
1329 result = PyObject_CallObject(method, args);
1330 if (!result) {
1331 Py_CLEAR(cursor);
1332 }
1333
1334 error:
1335 Py_XDECREF(result);
1336 Py_XDECREF(method);
1337
1338 return cursor;
1339 }
1340
1341 /* ------------------------- COLLATION CODE ------------------------ */
1342
1343 static int
pysqlite_collation_callback(void * context,int text1_length,const void * text1_data,int text2_length,const void * text2_data)1344 pysqlite_collation_callback(
1345 void* context,
1346 int text1_length, const void* text1_data,
1347 int text2_length, const void* text2_data)
1348 {
1349 PyObject* callback = (PyObject*)context;
1350 PyObject* string1 = 0;
1351 PyObject* string2 = 0;
1352 #ifdef WITH_THREAD
1353 PyGILState_STATE gilstate;
1354 #endif
1355 PyObject* retval = NULL;
1356 long longval;
1357 int result = 0;
1358 #ifdef WITH_THREAD
1359 gilstate = PyGILState_Ensure();
1360 #endif
1361
1362 if (PyErr_Occurred()) {
1363 goto finally;
1364 }
1365
1366 string1 = PyString_FromStringAndSize((const char*)text1_data, text1_length);
1367 string2 = PyString_FromStringAndSize((const char*)text2_data, text2_length);
1368
1369 if (!string1 || !string2) {
1370 goto finally; /* failed to allocate strings */
1371 }
1372
1373 retval = PyObject_CallFunctionObjArgs(callback, string1, string2, NULL);
1374
1375 if (!retval) {
1376 /* execution failed */
1377 goto finally;
1378 }
1379
1380 longval = PyLong_AsLongAndOverflow(retval, &result);
1381 if (longval == -1 && PyErr_Occurred()) {
1382 PyErr_Clear();
1383 result = 0;
1384 }
1385 else if (!result) {
1386 if (longval > 0)
1387 result = 1;
1388 else if (longval < 0)
1389 result = -1;
1390 }
1391
1392 finally:
1393 Py_XDECREF(string1);
1394 Py_XDECREF(string2);
1395 Py_XDECREF(retval);
1396 #ifdef WITH_THREAD
1397 PyGILState_Release(gilstate);
1398 #endif
1399 return result;
1400 }
1401
1402 static PyObject *
pysqlite_connection_interrupt(pysqlite_Connection * self,PyObject * args)1403 pysqlite_connection_interrupt(pysqlite_Connection* self, PyObject* args)
1404 {
1405 PyObject* retval = NULL;
1406
1407 if (!pysqlite_check_connection(self)) {
1408 goto finally;
1409 }
1410
1411 sqlite3_interrupt(self->db);
1412
1413 Py_INCREF(Py_None);
1414 retval = Py_None;
1415
1416 finally:
1417 return retval;
1418 }
1419
1420 /* Function author: Paul Kippes <[email protected]>
1421 * Class method of Connection to call the Python function _iterdump
1422 * of the sqlite3 module.
1423 */
1424 static PyObject *
pysqlite_connection_iterdump(pysqlite_Connection * self,PyObject * args)1425 pysqlite_connection_iterdump(pysqlite_Connection* self, PyObject* args)
1426 {
1427 PyObject* retval = NULL;
1428 PyObject* module = NULL;
1429 PyObject* module_dict;
1430 PyObject* pyfn_iterdump;
1431
1432 if (!pysqlite_check_connection(self)) {
1433 goto finally;
1434 }
1435
1436 module = PyImport_ImportModule(MODULE_NAME ".dump");
1437 if (!module) {
1438 goto finally;
1439 }
1440
1441 module_dict = PyModule_GetDict(module);
1442 if (!module_dict) {
1443 goto finally;
1444 }
1445
1446 pyfn_iterdump = PyDict_GetItemString(module_dict, "_iterdump");
1447 if (!pyfn_iterdump) {
1448 PyErr_SetString(pysqlite_OperationalError, "Failed to obtain _iterdump() reference");
1449 goto finally;
1450 }
1451
1452 args = PyTuple_New(1);
1453 if (!args) {
1454 goto finally;
1455 }
1456 Py_INCREF(self);
1457 PyTuple_SetItem(args, 0, (PyObject*)self);
1458 retval = PyObject_CallObject(pyfn_iterdump, args);
1459
1460 finally:
1461 Py_XDECREF(args);
1462 Py_XDECREF(module);
1463 return retval;
1464 }
1465
1466 static PyObject *
pysqlite_connection_create_collation(pysqlite_Connection * self,PyObject * args)1467 pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args)
1468 {
1469 PyObject* callable;
1470 PyObject* uppercase_name = 0;
1471 PyObject* name;
1472 PyObject* retval;
1473 char* chk;
1474 int rc;
1475
1476 if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) {
1477 goto finally;
1478 }
1479
1480 if (!PyArg_ParseTuple(args, "SO:create_collation(name, callback)",
1481 &name, &callable)) {
1482 goto finally;
1483 }
1484
1485 uppercase_name = PyObject_CallMethod((PyObject *)&PyString_Type,
1486 "upper", "O", name);
1487 if (!uppercase_name) {
1488 goto finally;
1489 }
1490
1491 chk = PyString_AS_STRING(uppercase_name);
1492 while (*chk) {
1493 if ((*chk >= '0' && *chk <= '9')
1494 || (*chk >= 'A' && *chk <= 'Z')
1495 || (*chk == '_'))
1496 {
1497 chk++;
1498 } else {
1499 PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name");
1500 goto finally;
1501 }
1502 }
1503
1504 if (callable != Py_None && !PyCallable_Check(callable)) {
1505 PyErr_SetString(PyExc_TypeError, "parameter must be callable");
1506 goto finally;
1507 }
1508
1509 if (callable != Py_None) {
1510 if (PyDict_SetItem(self->collations, uppercase_name, callable) == -1)
1511 goto finally;
1512 } else {
1513 if (PyDict_DelItem(self->collations, uppercase_name) == -1)
1514 goto finally;
1515 }
1516
1517 rc = sqlite3_create_collation(self->db,
1518 PyString_AsString(uppercase_name),
1519 SQLITE_UTF8,
1520 (callable != Py_None) ? callable : NULL,
1521 (callable != Py_None) ? pysqlite_collation_callback : NULL);
1522 if (rc != SQLITE_OK) {
1523 PyDict_DelItem(self->collations, uppercase_name);
1524 _pysqlite_seterror(self->db, NULL);
1525 goto finally;
1526 }
1527
1528 finally:
1529 Py_XDECREF(uppercase_name);
1530
1531 if (PyErr_Occurred()) {
1532 retval = NULL;
1533 } else {
1534 Py_INCREF(Py_None);
1535 retval = Py_None;
1536 }
1537
1538 return retval;
1539 }
1540
1541 /* Called when the connection is used as a context manager. Returns itself as a
1542 * convenience to the caller. */
1543 static PyObject *
pysqlite_connection_enter(pysqlite_Connection * self,PyObject * args)1544 pysqlite_connection_enter(pysqlite_Connection* self, PyObject* args)
1545 {
1546 Py_INCREF(self);
1547 return (PyObject*)self;
1548 }
1549
1550 /** Called when the connection is used as a context manager. If there was any
1551 * exception, a rollback takes place; otherwise we commit. */
1552 static PyObject *
pysqlite_connection_exit(pysqlite_Connection * self,PyObject * args)1553 pysqlite_connection_exit(pysqlite_Connection* self, PyObject* args)
1554 {
1555 PyObject* exc_type, *exc_value, *exc_tb;
1556 char* method_name;
1557 PyObject* result;
1558
1559 if (!PyArg_ParseTuple(args, "OOO", &exc_type, &exc_value, &exc_tb)) {
1560 return NULL;
1561 }
1562
1563 if (exc_type == Py_None && exc_value == Py_None && exc_tb == Py_None) {
1564 method_name = "commit";
1565 } else {
1566 method_name = "rollback";
1567 }
1568
1569 result = PyObject_CallMethod((PyObject*)self, method_name, "");
1570 if (!result) {
1571 return NULL;
1572 }
1573 Py_DECREF(result);
1574
1575 Py_INCREF(Py_False);
1576 return Py_False;
1577 }
1578
1579 static char connection_doc[] =
1580 PyDoc_STR("SQLite database connection object.");
1581
1582 static PyGetSetDef connection_getset[] = {
1583 {"isolation_level", (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level},
1584 {"total_changes", (getter)pysqlite_connection_get_total_changes, (setter)0},
1585 {NULL}
1586 };
1587
1588 static PyMethodDef connection_methods[] = {
1589 {"cursor", (PyCFunction)pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS,
1590 PyDoc_STR("Return a cursor for the connection.")},
1591 {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS,
1592 PyDoc_STR("Closes the connection.")},
1593 {"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS,
1594 PyDoc_STR("Commit the current transaction.")},
1595 {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS,
1596 PyDoc_STR("Roll back the current transaction.")},
1597 {"create_function", (PyCFunction)pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS,
1598 PyDoc_STR("Creates a new function. Non-standard.")},
1599 {"create_aggregate", (PyCFunction)pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS,
1600 PyDoc_STR("Creates a new aggregate. Non-standard.")},
1601 {"set_authorizer", (PyCFunction)pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS,
1602 PyDoc_STR("Sets authorizer callback. Non-standard.")},
1603 #ifdef HAVE_LOAD_EXTENSION
1604 {"enable_load_extension", (PyCFunction)pysqlite_enable_load_extension, METH_VARARGS,
1605 PyDoc_STR("Enable dynamic loading of SQLite extension modules. Non-standard.")},
1606 {"load_extension", (PyCFunction)pysqlite_load_extension, METH_VARARGS,
1607 PyDoc_STR("Load SQLite extension module. Non-standard.")},
1608 #endif
1609 {"set_progress_handler", (PyCFunction)pysqlite_connection_set_progress_handler, METH_VARARGS|METH_KEYWORDS,
1610 PyDoc_STR("Sets progress handler callback. Non-standard.")},
1611 {"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS,
1612 PyDoc_STR("Executes a SQL statement. Non-standard.")},
1613 {"executemany", (PyCFunction)pysqlite_connection_executemany, METH_VARARGS,
1614 PyDoc_STR("Repeatedly executes a SQL statement. Non-standard.")},
1615 {"executescript", (PyCFunction)pysqlite_connection_executescript, METH_VARARGS,
1616 PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
1617 {"create_collation", (PyCFunction)pysqlite_connection_create_collation, METH_VARARGS,
1618 PyDoc_STR("Creates a collation function. Non-standard.")},
1619 {"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS,
1620 PyDoc_STR("Abort any pending database operation. Non-standard.")},
1621 {"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS,
1622 PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")},
1623 {"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS,
1624 PyDoc_STR("For context manager. Non-standard.")},
1625 {"__exit__", (PyCFunction)pysqlite_connection_exit, METH_VARARGS,
1626 PyDoc_STR("For context manager. Non-standard.")},
1627 {NULL, NULL}
1628 };
1629
1630 static struct PyMemberDef connection_members[] =
1631 {
1632 {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), RO},
1633 {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), RO},
1634 {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), RO},
1635 {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), RO},
1636 {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), RO},
1637 {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), RO},
1638 {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), RO},
1639 {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), RO},
1640 {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), RO},
1641 {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), RO},
1642 {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)},
1643 {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)},
1644 {NULL}
1645 };
1646
1647 PyTypeObject pysqlite_ConnectionType = {
1648 PyVarObject_HEAD_INIT(NULL, 0)
1649 MODULE_NAME ".Connection", /* tp_name */
1650 sizeof(pysqlite_Connection), /* tp_basicsize */
1651 0, /* tp_itemsize */
1652 (destructor)pysqlite_connection_dealloc, /* tp_dealloc */
1653 0, /* tp_print */
1654 0, /* tp_getattr */
1655 0, /* tp_setattr */
1656 0, /* tp_compare */
1657 0, /* tp_repr */
1658 0, /* tp_as_number */
1659 0, /* tp_as_sequence */
1660 0, /* tp_as_mapping */
1661 0, /* tp_hash */
1662 (ternaryfunc)pysqlite_connection_call, /* tp_call */
1663 0, /* tp_str */
1664 0, /* tp_getattro */
1665 0, /* tp_setattro */
1666 0, /* tp_as_buffer */
1667 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1668 connection_doc, /* tp_doc */
1669 0, /* tp_traverse */
1670 0, /* tp_clear */
1671 0, /* tp_richcompare */
1672 0, /* tp_weaklistoffset */
1673 0, /* tp_iter */
1674 0, /* tp_iternext */
1675 connection_methods, /* tp_methods */
1676 connection_members, /* tp_members */
1677 connection_getset, /* tp_getset */
1678 0, /* tp_base */
1679 0, /* tp_dict */
1680 0, /* tp_descr_get */
1681 0, /* tp_descr_set */
1682 0, /* tp_dictoffset */
1683 (initproc)pysqlite_connection_init, /* tp_init */
1684 0, /* tp_alloc */
1685 0, /* tp_new */
1686 0 /* tp_free */
1687 };
1688
pysqlite_connection_setup_types(void)1689 extern int pysqlite_connection_setup_types(void)
1690 {
1691 pysqlite_ConnectionType.tp_new = PyType_GenericNew;
1692 return PyType_Ready(&pysqlite_ConnectionType);
1693 }
1694