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+
37+PyObject* cursor_iternext(Cursor *self);
38+
39+static 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+
77+int 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+
119+void 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+
140+PyObject* _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+
156+int 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+
237+PyObject* _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+
256+PyObject* 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+ */
288+PyObject* _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+
409+PyObject* _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+
706+error:
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+
720+PyObject* cursor_execute(Cursor* self, PyObject* args)
721+{
722+ return _query_execute(self, 0, args);
723+}
724+
725+PyObject* cursor_executemany(Cursor* self, PyObject* args)
726+{
727+ return _query_execute(self, 1, args);
728+}
729+
730+PyObject* 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+
804+error:
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+
819+PyObject* cursor_getiter(Cursor *self)
820+{
821+ Py_INCREF(self);
822+ return (PyObject*)self;
823+}
824+
825+PyObject* 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+
868+PyObject* 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+
881+PyObject* 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+
922+PyObject* 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+
951+PyObject* pysqlite_noop(Connection* self, PyObject* args)
952+{
953+ /* don't care, return None */
954+ Py_INCREF(Py_None);
955+ return Py_None;
956+}
957+
958+PyObject* 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+
974+static 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+
996+static 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+
1007+static char cursor_doc[] =
1008+PyDoc_STR("SQLite database cursor class.");
1009+
1010+PyTypeObject 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+
1053+extern 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