Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : static int
6 : : pysqlite_cursor_init_impl(pysqlite_Cursor *self,
7 : : pysqlite_Connection *connection);
8 : :
9 : : static int
10 : 1303 : pysqlite_cursor_init(PyObject *self, PyObject *args, PyObject *kwargs)
11 : : {
12 : 1303 : int return_value = -1;
13 : : pysqlite_Connection *connection;
14 : :
15 [ + + ]: 1303 : if ((Py_IS_TYPE(self, clinic_state()->CursorType) ||
16 [ + - + + ]: 1303 : Py_TYPE(self)->tp_new == clinic_state()->CursorType->tp_new) &&
17 [ - + ]: 3 : !_PyArg_NoKeywords("Cursor", kwargs)) {
18 : 0 : goto exit;
19 : : }
20 [ + - - + : 1303 : if (!_PyArg_CheckPositional("Cursor", PyTuple_GET_SIZE(args), 1, 1)) {
- - ]
21 : 0 : goto exit;
22 : : }
23 [ + + ]: 1303 : if (!PyObject_TypeCheck(PyTuple_GET_ITEM(args, 0), clinic_state()->ConnectionType)) {
24 : 1 : _PyArg_BadArgument("Cursor", "argument 1", (clinic_state()->ConnectionType)->tp_name, PyTuple_GET_ITEM(args, 0));
25 : 1 : goto exit;
26 : : }
27 : 1302 : connection = (pysqlite_Connection *)PyTuple_GET_ITEM(args, 0);
28 : 1302 : return_value = pysqlite_cursor_init_impl((pysqlite_Cursor *)self, connection);
29 : :
30 : 1303 : exit:
31 : 1303 : return return_value;
32 : : }
33 : :
34 : : PyDoc_STRVAR(pysqlite_cursor_execute__doc__,
35 : : "execute($self, sql, parameters=(), /)\n"
36 : : "--\n"
37 : : "\n"
38 : : "Executes an SQL statement.");
39 : :
40 : : #define PYSQLITE_CURSOR_EXECUTE_METHODDEF \
41 : : {"execute", _PyCFunction_CAST(pysqlite_cursor_execute), METH_FASTCALL, pysqlite_cursor_execute__doc__},
42 : :
43 : : static PyObject *
44 : : pysqlite_cursor_execute_impl(pysqlite_Cursor *self, PyObject *sql,
45 : : PyObject *parameters);
46 : :
47 : : static PyObject *
48 : 756 : pysqlite_cursor_execute(pysqlite_Cursor *self, PyObject *const *args, Py_ssize_t nargs)
49 : : {
50 : 756 : PyObject *return_value = NULL;
51 : : PyObject *sql;
52 : 756 : PyObject *parameters = NULL;
53 : :
54 [ + - - + : 756 : if (!_PyArg_CheckPositional("execute", nargs, 1, 2)) {
- - ]
55 : 0 : goto exit;
56 : : }
57 [ + + ]: 756 : if (!PyUnicode_Check(args[0])) {
58 : 1 : _PyArg_BadArgument("execute", "argument 1", "str", args[0]);
59 : 1 : goto exit;
60 : : }
61 [ - + ]: 755 : if (PyUnicode_READY(args[0]) == -1) {
62 : 0 : goto exit;
63 : : }
64 : 755 : sql = args[0];
65 [ + + ]: 755 : if (nargs < 2) {
66 : 575 : goto skip_optional;
67 : : }
68 : 180 : parameters = args[1];
69 : 755 : skip_optional:
70 : 755 : return_value = pysqlite_cursor_execute_impl(self, sql, parameters);
71 : :
72 : 756 : exit:
73 : 756 : return return_value;
74 : : }
75 : :
76 : : PyDoc_STRVAR(pysqlite_cursor_executemany__doc__,
77 : : "executemany($self, sql, seq_of_parameters, /)\n"
78 : : "--\n"
79 : : "\n"
80 : : "Repeatedly executes an SQL statement.");
81 : :
82 : : #define PYSQLITE_CURSOR_EXECUTEMANY_METHODDEF \
83 : : {"executemany", _PyCFunction_CAST(pysqlite_cursor_executemany), METH_FASTCALL, pysqlite_cursor_executemany__doc__},
84 : :
85 : : static PyObject *
86 : : pysqlite_cursor_executemany_impl(pysqlite_Cursor *self, PyObject *sql,
87 : : PyObject *seq_of_parameters);
88 : :
89 : : static PyObject *
90 : 29 : pysqlite_cursor_executemany(pysqlite_Cursor *self, PyObject *const *args, Py_ssize_t nargs)
91 : : {
92 : 29 : PyObject *return_value = NULL;
93 : : PyObject *sql;
94 : : PyObject *seq_of_parameters;
95 : :
96 [ + - - + : 29 : if (!_PyArg_CheckPositional("executemany", nargs, 2, 2)) {
- - ]
97 : 0 : goto exit;
98 : : }
99 [ + + ]: 29 : if (!PyUnicode_Check(args[0])) {
100 : 1 : _PyArg_BadArgument("executemany", "argument 1", "str", args[0]);
101 : 1 : goto exit;
102 : : }
103 [ - + ]: 28 : if (PyUnicode_READY(args[0]) == -1) {
104 : 0 : goto exit;
105 : : }
106 : 28 : sql = args[0];
107 : 28 : seq_of_parameters = args[1];
108 : 28 : return_value = pysqlite_cursor_executemany_impl(self, sql, seq_of_parameters);
109 : :
110 : 29 : exit:
111 : 29 : return return_value;
112 : : }
113 : :
114 : : PyDoc_STRVAR(pysqlite_cursor_executescript__doc__,
115 : : "executescript($self, sql_script, /)\n"
116 : : "--\n"
117 : : "\n"
118 : : "Executes multiple SQL statements at once.");
119 : :
120 : : #define PYSQLITE_CURSOR_EXECUTESCRIPT_METHODDEF \
121 : : {"executescript", (PyCFunction)pysqlite_cursor_executescript, METH_O, pysqlite_cursor_executescript__doc__},
122 : :
123 : : static PyObject *
124 : : pysqlite_cursor_executescript_impl(pysqlite_Cursor *self,
125 : : const char *sql_script);
126 : :
127 : : static PyObject *
128 : 29 : pysqlite_cursor_executescript(pysqlite_Cursor *self, PyObject *arg)
129 : : {
130 : 29 : PyObject *return_value = NULL;
131 : : const char *sql_script;
132 : :
133 [ + + ]: 29 : if (!PyUnicode_Check(arg)) {
134 : 1 : _PyArg_BadArgument("executescript", "argument", "str", arg);
135 : 1 : goto exit;
136 : : }
137 : : Py_ssize_t sql_script_length;
138 : 28 : sql_script = PyUnicode_AsUTF8AndSize(arg, &sql_script_length);
139 [ + + ]: 28 : if (sql_script == NULL) {
140 : 1 : goto exit;
141 : : }
142 [ + + ]: 27 : if (strlen(sql_script) != (size_t)sql_script_length) {
143 : 1 : PyErr_SetString(PyExc_ValueError, "embedded null character");
144 : 1 : goto exit;
145 : : }
146 : 26 : return_value = pysqlite_cursor_executescript_impl(self, sql_script);
147 : :
148 : 29 : exit:
149 : 29 : return return_value;
150 : : }
151 : :
152 : : PyDoc_STRVAR(pysqlite_cursor_fetchone__doc__,
153 : : "fetchone($self, /)\n"
154 : : "--\n"
155 : : "\n"
156 : : "Fetches one row from the resultset.");
157 : :
158 : : #define PYSQLITE_CURSOR_FETCHONE_METHODDEF \
159 : : {"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS, pysqlite_cursor_fetchone__doc__},
160 : :
161 : : static PyObject *
162 : : pysqlite_cursor_fetchone_impl(pysqlite_Cursor *self);
163 : :
164 : : static PyObject *
165 : 619 : pysqlite_cursor_fetchone(pysqlite_Cursor *self, PyObject *Py_UNUSED(ignored))
166 : : {
167 : 619 : return pysqlite_cursor_fetchone_impl(self);
168 : : }
169 : :
170 : : PyDoc_STRVAR(pysqlite_cursor_fetchmany__doc__,
171 : : "fetchmany($self, /, size=1)\n"
172 : : "--\n"
173 : : "\n"
174 : : "Fetches several rows from the resultset.\n"
175 : : "\n"
176 : : " size\n"
177 : : " The default value is set by the Cursor.arraysize attribute.");
178 : :
179 : : #define PYSQLITE_CURSOR_FETCHMANY_METHODDEF \
180 : : {"fetchmany", _PyCFunction_CAST(pysqlite_cursor_fetchmany), METH_FASTCALL|METH_KEYWORDS, pysqlite_cursor_fetchmany__doc__},
181 : :
182 : : static PyObject *
183 : : pysqlite_cursor_fetchmany_impl(pysqlite_Cursor *self, int maxrows);
184 : :
185 : : static PyObject *
186 : 6 : pysqlite_cursor_fetchmany(pysqlite_Cursor *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
187 : : {
188 : 6 : PyObject *return_value = NULL;
189 : : static const char * const _keywords[] = {"size", NULL};
190 : : static _PyArg_Parser _parser = {NULL, _keywords, "fetchmany", 0};
191 : : PyObject *argsbuf[1];
192 [ + + ]: 6 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
193 : 6 : int maxrows = self->arraysize;
194 : :
195 [ + + + - : 6 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ - - + ]
196 [ - + ]: 6 : if (!args) {
197 : 0 : goto exit;
198 : : }
199 [ + + ]: 6 : if (!noptargs) {
200 : 2 : goto skip_optional_pos;
201 : : }
202 : 4 : maxrows = _PyLong_AsInt(args[0]);
203 [ - + - - ]: 4 : if (maxrows == -1 && PyErr_Occurred()) {
204 : 0 : goto exit;
205 : : }
206 : 4 : skip_optional_pos:
207 : 6 : return_value = pysqlite_cursor_fetchmany_impl(self, maxrows);
208 : :
209 : 6 : exit:
210 : 6 : return return_value;
211 : : }
212 : :
213 : : PyDoc_STRVAR(pysqlite_cursor_fetchall__doc__,
214 : : "fetchall($self, /)\n"
215 : : "--\n"
216 : : "\n"
217 : : "Fetches all rows from the resultset.");
218 : :
219 : : #define PYSQLITE_CURSOR_FETCHALL_METHODDEF \
220 : : {"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS, pysqlite_cursor_fetchall__doc__},
221 : :
222 : : static PyObject *
223 : : pysqlite_cursor_fetchall_impl(pysqlite_Cursor *self);
224 : :
225 : : static PyObject *
226 : 72 : pysqlite_cursor_fetchall(pysqlite_Cursor *self, PyObject *Py_UNUSED(ignored))
227 : : {
228 : 72 : return pysqlite_cursor_fetchall_impl(self);
229 : : }
230 : :
231 : : PyDoc_STRVAR(pysqlite_cursor_setinputsizes__doc__,
232 : : "setinputsizes($self, sizes, /)\n"
233 : : "--\n"
234 : : "\n"
235 : : "Required by DB-API. Does nothing in sqlite3.");
236 : :
237 : : #define PYSQLITE_CURSOR_SETINPUTSIZES_METHODDEF \
238 : : {"setinputsizes", (PyCFunction)pysqlite_cursor_setinputsizes, METH_O, pysqlite_cursor_setinputsizes__doc__},
239 : :
240 : : PyDoc_STRVAR(pysqlite_cursor_setoutputsize__doc__,
241 : : "setoutputsize($self, size, column=None, /)\n"
242 : : "--\n"
243 : : "\n"
244 : : "Required by DB-API. Does nothing in sqlite3.");
245 : :
246 : : #define PYSQLITE_CURSOR_SETOUTPUTSIZE_METHODDEF \
247 : : {"setoutputsize", _PyCFunction_CAST(pysqlite_cursor_setoutputsize), METH_FASTCALL, pysqlite_cursor_setoutputsize__doc__},
248 : :
249 : : static PyObject *
250 : : pysqlite_cursor_setoutputsize_impl(pysqlite_Cursor *self, PyObject *size,
251 : : PyObject *column);
252 : :
253 : : static PyObject *
254 : 2 : pysqlite_cursor_setoutputsize(pysqlite_Cursor *self, PyObject *const *args, Py_ssize_t nargs)
255 : : {
256 : 2 : PyObject *return_value = NULL;
257 : : PyObject *size;
258 : 2 : PyObject *column = Py_None;
259 : :
260 [ + - - + : 2 : if (!_PyArg_CheckPositional("setoutputsize", nargs, 1, 2)) {
- - ]
261 : 0 : goto exit;
262 : : }
263 : 2 : size = args[0];
264 [ + + ]: 2 : if (nargs < 2) {
265 : 1 : goto skip_optional;
266 : : }
267 : 1 : column = args[1];
268 : 2 : skip_optional:
269 : 2 : return_value = pysqlite_cursor_setoutputsize_impl(self, size, column);
270 : :
271 : 2 : exit:
272 : 2 : return return_value;
273 : : }
274 : :
275 : : PyDoc_STRVAR(pysqlite_cursor_close__doc__,
276 : : "close($self, /)\n"
277 : : "--\n"
278 : : "\n"
279 : : "Closes the cursor.");
280 : :
281 : : #define PYSQLITE_CURSOR_CLOSE_METHODDEF \
282 : : {"close", (PyCFunction)pysqlite_cursor_close, METH_NOARGS, pysqlite_cursor_close__doc__},
283 : :
284 : : static PyObject *
285 : : pysqlite_cursor_close_impl(pysqlite_Cursor *self);
286 : :
287 : : static PyObject *
288 : 144 : pysqlite_cursor_close(pysqlite_Cursor *self, PyObject *Py_UNUSED(ignored))
289 : : {
290 : 144 : return pysqlite_cursor_close_impl(self);
291 : : }
292 : : /*[clinic end generated code: output=2b9c6a3ca8a8caff input=a9049054013a1b77]*/
|
