History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Modules/_sqlite/cursor.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Modules/_sqlite/cursor.c+1057−0
@@ -0,0 +1,1057 @@
1/* cursor.c - the cursor type
2 *
3 * Copyright (C) 2004-2006 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 "cursor.h"
25#include "module.h"
26#include "util.h"
27#include "sqlitecompat.h"
28
29/* used to decide wether to call PyInt_FromLong or PyLong_FromLongLong */
30#ifndef INT32_MIN
31#define INT32_MIN (-2147483647 - 1)
32#endif
33#ifndef INT32_MAX
34#define INT32_MAX 2147483647
35#endif
36
37PyObject* cursor_iternext(Cursor *self);
38
39static StatementKind detect_statement_type(char* statement)
40{
41 char buf[20];
42 char* src;
43 char* dst;
44
45 src = statement;
46 /* skip over whitepace */
47 while (*src == '\r' || *src == '\n' || *src == ' ' || *src == '\t') {
48 src++;
49 }
50
51 if (*src == 0)
52 return STATEMENT_INVALID;
53
54 dst = buf;
55 *dst = 0;
56 while (isalpha(*src) && dst - buf < sizeof(buf) - 2) {
57 *dst++ = tolower(*src++);
58 }
59
60 *dst = 0;
61
62 if (!strcmp(buf, "select")) {
63 return STATEMENT_SELECT;
64 } else if (!strcmp(buf, "insert")) {
65 return STATEMENT_INSERT;
66 } else if (!strcmp(buf, "update")) {
67 return STATEMENT_UPDATE;
68 } else if (!strcmp(buf, "delete")) {
69 return STATEMENT_DELETE;
70 } else if (!strcmp(buf, "replace")) {
71 return STATEMENT_REPLACE;
72 } else {
73 return STATEMENT_OTHER;
74 }
75}
76
77int cursor_init(Cursor* self, PyObject* args, PyObject* kwargs)
78{
79 Connection* connection;
80
81 if (!PyArg_ParseTuple(args, "O!", &ConnectionType, &connection))
82 {
83 return -1;
84 }
85
86 Py_INCREF(connection);
87 self->connection = connection;
88 self->statement = NULL;
89 self->next_row = NULL;
90
91 self->row_cast_map = PyList_New(0);
92 if (!self->row_cast_map) {
93 return -1;
94 }
95
96 Py_INCREF(Py_None);
97 self->description = Py_None;
98
99 Py_INCREF(Py_None);
100 self->lastrowid= Py_None;
101
102 self->arraysize = 1;
103
104 self->rowcount = PyInt_FromLong(-1L);
105 if (!self->rowcount) {
106 return -1;
107 }
108
109 Py_INCREF(Py_None);
110 self->row_factory = Py_None;
111
112 if (!check_thread(self->connection)) {
113 return -1;
114 }
115
116 return 0;
117}
118
119void cursor_dealloc(Cursor* self)
120{
121 int rc;
122
123 /* Reset the statement if the user has not closed the cursor */
124 if (self->statement) {
125 rc = statement_reset(self->statement);
126 Py_DECREF(self->statement);
127 }
128
129 Py_XDECREF(self->connection);
130 Py_XDECREF(self->row_cast_map);
131 Py_XDECREF(self->description);
132 Py_XDECREF(self->lastrowid);
133 Py_XDECREF(self->rowcount);
134 Py_XDECREF(self->row_factory);
135 Py_XDECREF(self->next_row);
136
137 self->ob_type->tp_free((PyObject*)self);
138}
139
140PyObject* _get_converter(PyObject* key)
141{
142 PyObject* upcase_key;
143 PyObject* retval;
144
145 upcase_key = PyObject_CallMethod(key, "upper", "");
146 if (!upcase_key) {
147 return NULL;
148 }
149
150 retval = PyDict_GetItem(converters, upcase_key);
151 Py_DECREF(upcase_key);
152
153 return retval;
154}
155
156int build_row_cast_map(Cursor* self)
157{
158 int i;
159 const char* type_start = (const char*)-1;
160 const char* pos;
161
162 const char* colname;
163 const char* decltype;
164 PyObject* py_decltype;
165 PyObject* converter;
166 PyObject* key;
167
168 if (!self->connection->detect_types) {
169 return 0;
170 }
171
172 Py_XDECREF(self->row_cast_map);
173 self->row_cast_map = PyList_New(0);
174
175 for (i = 0; i < sqlite3_column_count(self->statement->st); i++) {
176 converter = NULL;
177
178 if (self->connection->detect_types | PARSE_COLNAMES) {
179 colname = sqlite3_column_name(self->statement->st, i);
180 if (colname) {
181 for (pos = colname; *pos != 0; pos++) {
182 if (*pos == '[') {
183 type_start = pos + 1;
184 } else if (*pos == ']' && type_start != (const char*)-1) {
185 key = PyString_FromStringAndSize(type_start, pos - type_start);
186 if (!key) {
187 /* creating a string failed, but it is too complicated
188 * to propagate the error here, we just assume there is
189 * no converter and proceed */
190 break;
191 }
192
193 converter = _get_converter(key);
194 Py_DECREF(key);
195 break;
196 }
197 }
198 }
199 }
200
201 if (!converter && self->connection->detect_types | PARSE_DECLTYPES) {
202 decltype = sqlite3_column_decltype(self->statement->st, i);
203 if (decltype) {
204 for (pos = decltype;;pos++) {
205 if (*pos == ' ' || *pos == 0) {
206 py_decltype = PyString_FromStringAndSize(decltype, pos - decltype);
207 if (!py_decltype) {
208 return -1;
209 }
210 break;
211 }
212 }
213
214 converter = _get_converter(py_decltype);
215 Py_DECREF(py_decltype);
216 }
217 }
218
219 if (!converter) {
220 converter = Py_None;
221 }
222
223 if (PyList_Append(self->row_cast_map, converter) != 0) {
224 if (converter != Py_None) {
225 Py_DECREF(converter);
226 }
227 Py_XDECREF(self->row_cast_map);
228 self->row_cast_map = NULL;
229
230 return -1;
231 }
232 }
233
234 return 0;
235}
236
237PyObject* _build_column_name(const char* colname)
238{
239 const char* pos;
240
241 if (!colname) {
242 Py_INCREF(Py_None);
243 return Py_None;
244 }
245
246 for (pos = colname;; pos++) {
247 if (*pos == 0 || *pos == '[') {
248 if ((*pos == '[') && (pos > colname) && (*(pos-1) == ' ')) {
249 pos--;
250 }
251 return PyString_FromStringAndSize(colname, pos - colname);
252 }
253 }
254}
255
256PyObject* unicode_from_string(const char* val_str, int optimize)
257{
258 const char* check;
259 int is_ascii = 0;
260
261 if (optimize) {
262 is_ascii = 1;
263
264 check = val_str;
265 while (*check) {
266 if (*check & 0x80) {
267 is_ascii = 0;
268 break;
269 }
270
271 check++;
272 }
273 }
274
275 if (is_ascii) {
276 return PyString_FromString(val_str);
277 } else {
278 return PyUnicode_DecodeUTF8(val_str, strlen(val_str), NULL);
279 }
280}
281
282/*
283 * Returns a row from the currently active SQLite statement
284 *
285 * Precondidition:
286 * - sqlite3_step() has been called before and it returned SQLITE_ROW.
287 */
288PyObject* _fetch_one_row(Cursor* self)
289{
290 int i, numcols;
291 PyObject* row;
292 PyObject* item = NULL;
293 int coltype;
294 PY_LONG_LONG intval;
295 PyObject* converter;
296 PyObject* converted;
297 Py_ssize_t nbytes;
298 PyObject* buffer;
299 void* raw_buffer;
300 const char* val_str;
301 char buf[200];
302 const char* colname;
303
304 Py_BEGIN_ALLOW_THREADS
305 numcols = sqlite3_data_count(self->statement->st);
306 Py_END_ALLOW_THREADS
307
308 row = PyTuple_New(numcols);
309 if (!row) {
310 return NULL;
311 }
312
313 for (i = 0; i < numcols; i++) {
314 if (self->connection->detect_types) {
315 converter = PyList_GetItem(self->row_cast_map, i);
316 if (!converter) {
317 converter = Py_None;
318 }
319 } else {
320 converter = Py_None;
321 }
322
323 if (converter != Py_None) {
324 nbytes = sqlite3_column_bytes(self->statement->st, i);
325 val_str = (const char*)sqlite3_column_blob(self->statement->st, i);
326 if (!val_str) {
327 Py_INCREF(Py_None);
328 converted = Py_None;
329 } else {
330 item = PyString_FromStringAndSize(val_str, nbytes);
331 if (!item) {
332 return NULL;
333 }
334 converted = PyObject_CallFunction(converter, "O", item);
335 Py_DECREF(item);
336 if (!converted) {
337 break;
338 }
339 }
340 } else {
341 Py_BEGIN_ALLOW_THREADS
342 coltype = sqlite3_column_type(self->statement->st, i);
343 Py_END_ALLOW_THREADS
344 if (coltype == SQLITE_NULL) {
345 Py_INCREF(Py_None);
346 converted = Py_None;
347 } else if (coltype == SQLITE_INTEGER) {
348 intval = sqlite3_column_int64(self->statement->st, i);
349 if (intval < INT32_MIN || intval > INT32_MAX) {
350 converted = PyLong_FromLongLong(intval);
351 } else {
352 converted = PyInt_FromLong((long)intval);
353 }
354 } else if (coltype == SQLITE_FLOAT) {
355 converted = PyFloat_FromDouble(sqlite3_column_double(self->statement->st, i));
356 } else if (coltype == SQLITE_TEXT) {
357 val_str = (const char*)sqlite3_column_text(self->statement->st, i);
358 if ((self->connection->text_factory == (PyObject*)&PyUnicode_Type)
359 || (self->connection->text_factory == OptimizedUnicode)) {
360
361 converted = unicode_from_string(val_str,
362 self->connection->text_factory == OptimizedUnicode ? 1 : 0);
363
364 if (!converted) {
365 colname = sqlite3_column_name(self->statement->st, i);
366 if (!colname) {
367 colname = "<unknown column name>";
368 }
369 PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'",
370 colname , val_str);
371 PyErr_SetString(OperationalError, buf);
372 }
373 } else if (self->connection->text_factory == (PyObject*)&PyString_Type) {
374 converted = PyString_FromString(val_str);
375 } else {
376 converted = PyObject_CallFunction(self->connection->text_factory, "s", val_str);
377 }
378 } else {
379 /* coltype == SQLITE_BLOB */
380 nbytes = sqlite3_column_bytes(self->statement->st, i);
381 buffer = PyBuffer_New(nbytes);
382 if (!buffer) {
383 break;
384 }
385 if (PyObject_AsWriteBuffer(buffer, &raw_buffer, &nbytes)) {
386 break;
387 }
388 memcpy(raw_buffer, sqlite3_column_blob(self->statement->st, i), nbytes);
389 converted = buffer;
390 }
391 }
392
393 if (converted) {
394 PyTuple_SetItem(row, i, converted);
395 } else {
396 Py_INCREF(Py_None);
397 PyTuple_SetItem(row, i, Py_None);
398 }
399 }
400
401 if (PyErr_Occurred()) {
402 Py_DECREF(row);
403 row = NULL;
404 }
405
406 return row;
407}
408
409PyObject* _query_execute(Cursor* self, int multiple, PyObject* args)
410{
411 PyObject* operation;
412 PyObject* operation_bytestr = NULL;
413 char* operation_cstr;
414 PyObject* parameters_list = NULL;
415 PyObject* parameters_iter = NULL;
416 PyObject* parameters = NULL;
417 int i;
418 int rc;
419 PyObject* func_args;
420 PyObject* result;
421 int numcols;
422 PY_LONG_LONG lastrowid;
423 int statement_type;
424 PyObject* descriptor;
425 PyObject* second_argument = NULL;
426 long rowcount = 0;
427
428 if (!check_thread(self->connection) || !check_connection(self->connection)) {
429 return NULL;
430 }
431
432 Py_XDECREF(self->next_row);
433 self->next_row = NULL;
434
435 if (multiple) {
436 /* executemany() */
437 if (!PyArg_ParseTuple(args, "OO", &operation, &second_argument)) {
438 return NULL;
439 }
440
441 if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
442 PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
443 return NULL;
444 }
445
446 if (PyIter_Check(second_argument)) {
447 /* iterator */
448 Py_INCREF(second_argument);
449 parameters_iter = second_argument;
450 } else {
451 /* sequence */
452 parameters_iter = PyObject_GetIter(second_argument);
453 if (!parameters_iter) {
454 return NULL;
455 }
456 }
457 } else {
458 /* execute() */
459 if (!PyArg_ParseTuple(args, "O|O", &operation, &second_argument)) {
460 return NULL;
461 }
462
463 if (!PyString_Check(operation) && !PyUnicode_Check(operation)) {
464 PyErr_SetString(PyExc_ValueError, "operation parameter must be str or unicode");
465 return NULL;
466 }
467
468 parameters_list = PyList_New(0);
469 if (!parameters_list) {
470 return NULL;
471 }
472
473 if (second_argument == NULL) {
474 second_argument = PyTuple_New(0);
475 if (!second_argument) {
476 goto error;
477 }
478 } else {
479 Py_INCREF(second_argument);
480 }
481 if (PyList_Append(parameters_list, second_argument) != 0) {
482 Py_DECREF(second_argument);
483 goto error;
484 }
485 Py_DECREF(second_argument);
486
487 parameters_iter = PyObject_GetIter(parameters_list);
488 if (!parameters_iter) {
489 goto error;
490 }
491 }
492
493 if (self->statement != NULL) {
494 /* There is an active statement */
495 rc = statement_reset(self->statement);
496 }
497
498 if (PyString_Check(operation)) {
499 operation_cstr = PyString_AsString(operation);
500 } else {
501 operation_bytestr = PyUnicode_AsUTF8String(operation);
502 if (!operation_bytestr) {
503 goto error;
504 }
505
506 operation_cstr = PyString_AsString(operation_bytestr);
507 }
508
509 /* reset description and rowcount */
510 Py_DECREF(self->description);
511 Py_INCREF(Py_None);
512 self->description = Py_None;
513
514 Py_DECREF(self->rowcount);
515 self->rowcount = PyInt_FromLong(-1L);
516 if (!self->rowcount) {
517 goto error;
518 }
519
520 statement_type = detect_statement_type(operation_cstr);
521 if (self->connection->begin_statement) {
522 switch (statement_type) {
523 case STATEMENT_UPDATE:
524 case STATEMENT_DELETE:
525 case STATEMENT_INSERT:
526 case STATEMENT_REPLACE:
527 if (!self->connection->inTransaction) {
528 result = _connection_begin(self->connection);
529 if (!result) {
530 goto error;
531 }
532 Py_DECREF(result);
533 }
534 break;
535 case STATEMENT_OTHER:
536 /* it's a DDL statement or something similar
537 - we better COMMIT first so it works for all cases */
538 if (self->connection->inTransaction) {
539 result = connection_commit(self->connection, NULL);
540 if (!result) {
541 goto error;
542 }
543 Py_DECREF(result);
544 }
545 break;
546 case STATEMENT_SELECT:
547 if (multiple) {
548 PyErr_SetString(ProgrammingError,
549 "You cannot execute SELECT statements in executemany().");
550 goto error;
551 }
552 break;
553 }
554 }
555
556 func_args = PyTuple_New(1);
557 if (!func_args) {
558 goto error;
559 }
560 Py_INCREF(operation);
561 if (PyTuple_SetItem(func_args, 0, operation) != 0) {
562 goto error;
563 }
564
565 if (self->statement) {
566 (void)statement_reset(self->statement);
567 Py_DECREF(self->statement);
568 }
569
570 self->statement = (Statement*)cache_get(self->connection->statement_cache, func_args);
571 Py_DECREF(func_args);
572
573 if (!self->statement) {
574 goto error;
575 }
576
577 if (self->statement->in_use) {
578 Py_DECREF(self->statement);
579 self->statement = PyObject_New(Statement, &StatementType);
580 if (!self->statement) {
581 goto error;
582 }
583 rc = statement_create(self->statement, self->connection, operation);
584 if (rc != SQLITE_OK) {
585 self->statement = 0;
586 goto error;
587 }
588 }
589
590 statement_reset(self->statement);
591 statement_mark_dirty(self->statement);
592
593 while (1) {
594 parameters = PyIter_Next(parameters_iter);
595 if (!parameters) {
596 break;
597 }
598
599 statement_mark_dirty(self->statement);
600
601 statement_bind_parameters(self->statement, parameters);
602 if (PyErr_Occurred()) {
603 goto error;
604 }
605
606 if (build_row_cast_map(self) != 0) {
607 PyErr_SetString(OperationalError, "Error while building row_cast_map");
608 goto error;
609 }
610
611 rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection);
612 if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
613 rc = statement_reset(self->statement);
614 if (rc == SQLITE_SCHEMA) {
615 rc = statement_recompile(self->statement, parameters);
616 if (rc == SQLITE_OK) {
617 rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection);
618 } else {
619 _seterror(self->connection->db);
620 goto error;
621 }
622 } else {
623 if (PyErr_Occurred()) {
624 /* there was an error that occurred in a user-defined callback */
625 if (_enable_callback_tracebacks) {
626 PyErr_Print();
627 } else {
628 PyErr_Clear();
629 }
630 }
631 _seterror(self->connection->db);
632 goto error;
633 }
634 }
635
636 if (rc == SQLITE_ROW || (rc == SQLITE_DONE && statement_type == STATEMENT_SELECT)) {
637 Py_BEGIN_ALLOW_THREADS
638 numcols = sqlite3_column_count(self->statement->st);
639 Py_END_ALLOW_THREADS
640
641 if (self->description == Py_None) {
642 Py_DECREF(self->description);
643 self->description = PyTuple_New(numcols);
644 if (!self->description) {
645 goto error;
646 }
647 for (i = 0; i < numcols; i++) {
648 descriptor = PyTuple_New(7);
649 if (!descriptor) {
650 goto error;
651 }
652 PyTuple_SetItem(descriptor, 0, _build_column_name(sqlite3_column_name(self->statement->st, i)));
653 Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 1, Py_None);
654 Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 2, Py_None);
655 Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 3, Py_None);
656 Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 4, Py_None);
657 Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 5, Py_None);
658 Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 6, Py_None);
659 PyTuple_SetItem(self->description, i, descriptor);
660 }
661 }
662 }
663
664 if (rc == SQLITE_ROW) {
665 if (multiple) {
666 PyErr_SetString(ProgrammingError, "executemany() can only execute DML statements.");
667 goto error;
668 }
669
670 self->next_row = _fetch_one_row(self);
671 } else if (rc == SQLITE_DONE && !multiple) {
672 statement_reset(self->statement);
673 Py_DECREF(self->statement);
674 self->statement = 0;
675 }
676
677 switch (statement_type) {
678 case STATEMENT_UPDATE:
679 case STATEMENT_DELETE:
680 case STATEMENT_INSERT:
681 case STATEMENT_REPLACE:
682 Py_BEGIN_ALLOW_THREADS
683 rowcount += (long)sqlite3_changes(self->connection->db);
684 Py_END_ALLOW_THREADS
685 Py_DECREF(self->rowcount);
686 self->rowcount = PyInt_FromLong(rowcount);
687 }
688
689 Py_DECREF(self->lastrowid);
690 if (statement_type == STATEMENT_INSERT) {
691 Py_BEGIN_ALLOW_THREADS
692 lastrowid = sqlite3_last_insert_rowid(self->connection->db);
693 Py_END_ALLOW_THREADS
694 self->lastrowid = PyInt_FromLong((long)lastrowid);
695 } else {
696 Py_INCREF(Py_None);
697 self->lastrowid = Py_None;
698 }
699
700 if (multiple) {
701 rc = statement_reset(self->statement);
702 }
703 Py_XDECREF(parameters);
704 }
705
706error:
707 Py_XDECREF(operation_bytestr);
708 Py_XDECREF(parameters);
709 Py_XDECREF(parameters_iter);
710 Py_XDECREF(parameters_list);
711
712 if (PyErr_Occurred()) {
713 return NULL;
714 } else {
715 Py_INCREF(self);
716 return (PyObject*)self;
717 }
718}
719
720PyObject* cursor_execute(Cursor* self, PyObject* args)
721{
722 return _query_execute(self, 0, args);
723}
724
725PyObject* cursor_executemany(Cursor* self, PyObject* args)
726{
727 return _query_execute(self, 1, args);
728}
729
730PyObject* cursor_executescript(Cursor* self, PyObject* args)
731{
732 PyObject* script_obj;
733 PyObject* script_str = NULL;
734 const char* script_cstr;
735 sqlite3_stmt* statement;
736 int rc;
737 PyObject* result;
738 int statement_completed = 0;
739
740 if (!PyArg_ParseTuple(args, "O", &script_obj)) {
741 return NULL;
742 }
743
744 if (!check_thread(self->connection) || !check_connection(self->connection)) {
745 return NULL;
746 }
747
748 if (PyString_Check(script_obj)) {
749 script_cstr = PyString_AsString(script_obj);
750 } else if (PyUnicode_Check(script_obj)) {
751 script_str = PyUnicode_AsUTF8String(script_obj);
752 if (!script_str) {
753 return NULL;
754 }
755
756 script_cstr = PyString_AsString(script_str);
757 } else {
758 PyErr_SetString(PyExc_ValueError, "script argument must be unicode or string.");
759 return NULL;
760 }
761
762 /* commit first */
763 result = connection_commit(self->connection, NULL);
764 if (!result) {
765 goto error;
766 }
767 Py_DECREF(result);
768
769 while (1) {
770 if (!sqlite3_complete(script_cstr)) {
771 break;
772 }
773 statement_completed = 1;
774
775 rc = sqlite3_prepare(self->connection->db,
776 script_cstr,
777 -1,
778 &statement,
779 &script_cstr);
780 if (rc != SQLITE_OK) {
781 _seterror(self->connection->db);
782 goto error;
783 }
784
785 /* execute statement, and ignore results of SELECT statements */
786 rc = SQLITE_ROW;
787 while (rc == SQLITE_ROW) {
788 rc = _sqlite_step_with_busyhandler(statement, self->connection);
789 }
790
791 if (rc != SQLITE_DONE) {
792 (void)sqlite3_finalize(statement);
793 _seterror(self->connection->db);
794 goto error;
795 }
796
797 rc = sqlite3_finalize(statement);
798 if (rc != SQLITE_OK) {
799 _seterror(self->connection->db);
800 goto error;
801 }
802 }
803
804error:
805 Py_XDECREF(script_str);
806
807 if (!statement_completed) {
808 PyErr_SetString(ProgrammingError, "you did not provide a complete SQL statement");
809 }
810
811 if (PyErr_Occurred()) {
812 return NULL;
813 } else {
814 Py_INCREF(self);
815 return (PyObject*)self;
816 }
817}
818
819PyObject* cursor_getiter(Cursor *self)
820{
821 Py_INCREF(self);
822 return (PyObject*)self;
823}
824
825PyObject* cursor_iternext(Cursor *self)
826{
827 PyObject* next_row_tuple;
828 PyObject* next_row;
829 int rc;
830
831 if (!check_thread(self->connection) || !check_connection(self->connection)) {
832 return NULL;
833 }
834
835 if (!self->next_row) {
836 if (self->statement) {
837 (void)statement_reset(self->statement);
838 Py_DECREF(self->statement);
839 self->statement = NULL;
840 }
841 return NULL;
842 }
843
844 next_row_tuple = self->next_row;
845 self->next_row = NULL;
846
847 if (self->row_factory != Py_None) {
848 next_row = PyObject_CallFunction(self->row_factory, "OO", self, next_row_tuple);
849 Py_DECREF(next_row_tuple);
850 } else {
851 next_row = next_row_tuple;
852 }
853
854 rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection);
855 if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
856 Py_DECREF(next_row);
857 _seterror(self->connection->db);
858 return NULL;
859 }
860
861 if (rc == SQLITE_ROW) {
862 self->next_row = _fetch_one_row(self);
863 }
864
865 return next_row;
866}
867
868PyObject* cursor_fetchone(Cursor* self, PyObject* args)
869{
870 PyObject* row;
871
872 row = cursor_iternext(self);
873 if (!row && !PyErr_Occurred()) {
874 Py_INCREF(Py_None);
875 return Py_None;
876 }
877
878 return row;
879}
880
881PyObject* cursor_fetchmany(Cursor* self, PyObject* args)
882{
883 PyObject* row;
884 PyObject* list;
885 int maxrows = self->arraysize;
886 int counter = 0;
887
888 if (!PyArg_ParseTuple(args, "|i", &maxrows)) {
889 return NULL;
890 }
891
892 list = PyList_New(0);
893 if (!list) {
894 return NULL;
895 }
896
897 /* just make sure we enter the loop */
898 row = Py_None;
899
900 while (row) {
901 row = cursor_iternext(self);
902 if (row) {
903 PyList_Append(list, row);
904 Py_DECREF(row);
905 } else {
906 break;
907 }
908
909 if (++counter == maxrows) {
910 break;
911 }
912 }
913
914 if (PyErr_Occurred()) {
915 Py_DECREF(list);
916 return NULL;
917 } else {
918 return list;
919 }
920}
921
922PyObject* cursor_fetchall(Cursor* self, PyObject* args)
923{
924 PyObject* row;
925 PyObject* list;
926
927 list = PyList_New(0);
928 if (!list) {
929 return NULL;
930 }
931
932 /* just make sure we enter the loop */
933 row = (PyObject*)Py_None;
934
935 while (row) {
936 row = cursor_iternext(self);
937 if (row) {
938 PyList_Append(list, row);
939 Py_DECREF(row);
940 }
941 }
942
943 if (PyErr_Occurred()) {
944 Py_DECREF(list);
945 return NULL;
946 } else {
947 return list;
948 }
949}
950
951PyObject* pysqlite_noop(Connection* self, PyObject* args)
952{
953 /* don't care, return None */
954 Py_INCREF(Py_None);
955 return Py_None;
956}
957
958PyObject* cursor_close(Cursor* self, PyObject* args)
959{
960 if (!check_thread(self->connection) || !check_connection(self->connection)) {
961 return NULL;
962 }
963
964 if (self->statement) {
965 (void)statement_reset(self->statement);
966 Py_DECREF(self->statement);
967 self->statement = 0;
968 }
969
970 Py_INCREF(Py_None);
971 return Py_None;
972}
973
974static PyMethodDef cursor_methods[] = {
975 {"execute", (PyCFunction)cursor_execute, METH_VARARGS,
976 PyDoc_STR("Executes a SQL statement.")},
977 {"executemany", (PyCFunction)cursor_executemany, METH_VARARGS,
978 PyDoc_STR("Repeatedly executes a SQL statement.")},
979 {"executescript", (PyCFunction)cursor_executescript, METH_VARARGS,
980 PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
981 {"fetchone", (PyCFunction)cursor_fetchone, METH_NOARGS,
982 PyDoc_STR("Fetches several rows from the resultset.")},
983 {"fetchmany", (PyCFunction)cursor_fetchmany, METH_VARARGS,
984 PyDoc_STR("Fetches all rows from the resultset.")},
985 {"fetchall", (PyCFunction)cursor_fetchall, METH_NOARGS,
986 PyDoc_STR("Fetches one row from the resultset.")},
987 {"close", (PyCFunction)cursor_close, METH_NOARGS,
988 PyDoc_STR("Closes the cursor.")},
989 {"setinputsizes", (PyCFunction)pysqlite_noop, METH_VARARGS,
990 PyDoc_STR("Required by DB-API. Does nothing in pysqlite.")},
991 {"setoutputsize", (PyCFunction)pysqlite_noop, METH_VARARGS,
992 PyDoc_STR("Required by DB-API. Does nothing in pysqlite.")},
993 {NULL, NULL}
994};
995
996static struct PyMemberDef cursor_members[] =
997{
998 {"connection", T_OBJECT, offsetof(Cursor, connection), RO},
999 {"description", T_OBJECT, offsetof(Cursor, description), RO},
1000 {"arraysize", T_INT, offsetof(Cursor, arraysize), 0},
1001 {"lastrowid", T_OBJECT, offsetof(Cursor, lastrowid), RO},
1002 {"rowcount", T_OBJECT, offsetof(Cursor, rowcount), RO},
1003 {"row_factory", T_OBJECT, offsetof(Cursor, row_factory), 0},
1004 {NULL}
1005};
1006
1007static char cursor_doc[] =
1008PyDoc_STR("SQLite database cursor class.");
1009
1010PyTypeObject CursorType = {
1011 PyObject_HEAD_INIT(NULL)
1012 0, /* ob_size */
1013 MODULE_NAME ".Cursor", /* tp_name */
1014 sizeof(Cursor), /* tp_basicsize */
1015 0, /* tp_itemsize */
1016 (destructor)cursor_dealloc, /* tp_dealloc */
1017 0, /* tp_print */
1018 0, /* tp_getattr */
1019 0, /* tp_setattr */
1020 0, /* tp_compare */
1021 0, /* tp_repr */
1022 0, /* tp_as_number */
1023 0, /* tp_as_sequence */
1024 0, /* tp_as_mapping */
1025 0, /* tp_hash */
1026 0, /* tp_call */
1027 0, /* tp_str */
1028 0, /* tp_getattro */
1029 0, /* tp_setattro */
1030 0, /* tp_as_buffer */
1031 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_ITER|Py_TPFLAGS_BASETYPE, /* tp_flags */
1032 cursor_doc, /* tp_doc */
1033 0, /* tp_traverse */
1034 0, /* tp_clear */
1035 0, /* tp_richcompare */
1036 0, /* tp_weaklistoffset */
1037 (getiterfunc)cursor_getiter, /* tp_iter */
1038 (iternextfunc)cursor_iternext, /* tp_iternext */
1039 cursor_methods, /* tp_methods */
1040 cursor_members, /* tp_members */
1041 0, /* tp_getset */
1042 0, /* tp_base */
1043 0, /* tp_dict */
1044 0, /* tp_descr_get */
1045 0, /* tp_descr_set */
1046 0, /* tp_dictoffset */
1047 (initproc)cursor_init, /* tp_init */
1048 0, /* tp_alloc */
1049 0, /* tp_new */
1050 0 /* tp_free */
1051};
1052
1053extern int cursor_setup_types(void)
1054{
1055 CursorType.tp_new = PyType_GenericNew;
1056 return PyType_Ready(&CursorType);
1057}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t