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