1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4 
5 static int
6 pysqlite_connection_init_impl(pysqlite_Connection *self, PyObject *database,
7                               double timeout, int detect_types,
8                               const char *isolation_level,
9                               int check_same_thread, PyObject *factory,
10                               int cache_size, int uri);
11 
12 static int
pysqlite_connection_init(PyObject * self,PyObject * args,PyObject * kwargs)13 pysqlite_connection_init(PyObject *self, PyObject *args, PyObject *kwargs)
14 {
15     int return_value = -1;
16     static const char * const _keywords[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", "uri", NULL};
17     static _PyArg_Parser _parser = {NULL, _keywords, "Connection", 0};
18     PyObject *argsbuf[8];
19     PyObject * const *fastargs;
20     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
21     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
22     PyObject *database;
23     double timeout = 5.0;
24     int detect_types = 0;
25     const char *isolation_level = "";
26     int check_same_thread = 1;
27     PyObject *factory = (PyObject*)clinic_state()->ConnectionType;
28     int cache_size = 128;
29     int uri = 0;
30 
31     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 8, 0, argsbuf);
32     if (!fastargs) {
33         goto exit;
34     }
35     database = fastargs[0];
36     if (!noptargs) {
37         goto skip_optional_pos;
38     }
39     if (fastargs[1]) {
40         if (PyFloat_CheckExact(fastargs[1])) {
41             timeout = PyFloat_AS_DOUBLE(fastargs[1]);
42         }
43         else
44         {
45             timeout = PyFloat_AsDouble(fastargs[1]);
46             if (timeout == -1.0 && PyErr_Occurred()) {
47                 goto exit;
48             }
49         }
50         if (!--noptargs) {
51             goto skip_optional_pos;
52         }
53     }
54     if (fastargs[2]) {
55         detect_types = _PyLong_AsInt(fastargs[2]);
56         if (detect_types == -1 && PyErr_Occurred()) {
57             goto exit;
58         }
59         if (!--noptargs) {
60             goto skip_optional_pos;
61         }
62     }
63     if (fastargs[3]) {
64         if (!isolation_level_converter(fastargs[3], &isolation_level)) {
65             goto exit;
66         }
67         if (!--noptargs) {
68             goto skip_optional_pos;
69         }
70     }
71     if (fastargs[4]) {
72         check_same_thread = _PyLong_AsInt(fastargs[4]);
73         if (check_same_thread == -1 && PyErr_Occurred()) {
74             goto exit;
75         }
76         if (!--noptargs) {
77             goto skip_optional_pos;
78         }
79     }
80     if (fastargs[5]) {
81         factory = fastargs[5];
82         if (!--noptargs) {
83             goto skip_optional_pos;
84         }
85     }
86     if (fastargs[6]) {
87         cache_size = _PyLong_AsInt(fastargs[6]);
88         if (cache_size == -1 && PyErr_Occurred()) {
89             goto exit;
90         }
91         if (!--noptargs) {
92             goto skip_optional_pos;
93         }
94     }
95     uri = PyObject_IsTrue(fastargs[7]);
96     if (uri < 0) {
97         goto exit;
98     }
99 skip_optional_pos:
100     return_value = pysqlite_connection_init_impl((pysqlite_Connection *)self, database, timeout, detect_types, isolation_level, check_same_thread, factory, cache_size, uri);
101 
102 exit:
103     return return_value;
104 }
105 
106 PyDoc_STRVAR(pysqlite_connection_cursor__doc__,
107 "cursor($self, /, factory=<unrepresentable>)\n"
108 "--\n"
109 "\n"
110 "Return a cursor for the connection.");
111 
112 #define PYSQLITE_CONNECTION_CURSOR_METHODDEF    \
113     {"cursor", _PyCFunction_CAST(pysqlite_connection_cursor), METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_cursor__doc__},
114 
115 static PyObject *
116 pysqlite_connection_cursor_impl(pysqlite_Connection *self, PyObject *factory);
117 
118 static PyObject *
pysqlite_connection_cursor(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)119 pysqlite_connection_cursor(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
120 {
121     PyObject *return_value = NULL;
122     static const char * const _keywords[] = {"factory", NULL};
123     static _PyArg_Parser _parser = {NULL, _keywords, "cursor", 0};
124     PyObject *argsbuf[1];
125     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
126     PyObject *factory = NULL;
127 
128     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
129     if (!args) {
130         goto exit;
131     }
132     if (!noptargs) {
133         goto skip_optional_pos;
134     }
135     factory = args[0];
136 skip_optional_pos:
137     return_value = pysqlite_connection_cursor_impl(self, factory);
138 
139 exit:
140     return return_value;
141 }
142 
143 PyDoc_STRVAR(blobopen__doc__,
144 "blobopen($self, table, column, row, /, *, readonly=False, name=\'main\')\n"
145 "--\n"
146 "\n"
147 "Open and return a BLOB object.\n"
148 "\n"
149 "  table\n"
150 "    Table name.\n"
151 "  column\n"
152 "    Column name.\n"
153 "  row\n"
154 "    Row index.\n"
155 "  readonly\n"
156 "    Open the BLOB without write permissions.\n"
157 "  name\n"
158 "    Database name.");
159 
160 #define BLOBOPEN_METHODDEF    \
161     {"blobopen", _PyCFunction_CAST(blobopen), METH_FASTCALL|METH_KEYWORDS, blobopen__doc__},
162 
163 static PyObject *
164 blobopen_impl(pysqlite_Connection *self, const char *table, const char *col,
165               sqlite3_int64 row, int readonly, const char *name);
166 
167 static PyObject *
blobopen(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)168 blobopen(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
169 {
170     PyObject *return_value = NULL;
171     static const char * const _keywords[] = {"", "", "", "readonly", "name", NULL};
172     static _PyArg_Parser _parser = {NULL, _keywords, "blobopen", 0};
173     PyObject *argsbuf[5];
174     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
175     const char *table;
176     const char *col;
177     sqlite3_int64 row;
178     int readonly = 0;
179     const char *name = "main";
180 
181     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
182     if (!args) {
183         goto exit;
184     }
185     if (!PyUnicode_Check(args[0])) {
186         _PyArg_BadArgument("blobopen", "argument 1", "str", args[0]);
187         goto exit;
188     }
189     Py_ssize_t table_length;
190     table = PyUnicode_AsUTF8AndSize(args[0], &table_length);
191     if (table == NULL) {
192         goto exit;
193     }
194     if (strlen(table) != (size_t)table_length) {
195         PyErr_SetString(PyExc_ValueError, "embedded null character");
196         goto exit;
197     }
198     if (!PyUnicode_Check(args[1])) {
199         _PyArg_BadArgument("blobopen", "argument 2", "str", args[1]);
200         goto exit;
201     }
202     Py_ssize_t col_length;
203     col = PyUnicode_AsUTF8AndSize(args[1], &col_length);
204     if (col == NULL) {
205         goto exit;
206     }
207     if (strlen(col) != (size_t)col_length) {
208         PyErr_SetString(PyExc_ValueError, "embedded null character");
209         goto exit;
210     }
211     if (!sqlite3_int64_converter(args[2], &row)) {
212         goto exit;
213     }
214     if (!noptargs) {
215         goto skip_optional_kwonly;
216     }
217     if (args[3]) {
218         readonly = _PyLong_AsInt(args[3]);
219         if (readonly == -1 && PyErr_Occurred()) {
220             goto exit;
221         }
222         if (!--noptargs) {
223             goto skip_optional_kwonly;
224         }
225     }
226     if (!PyUnicode_Check(args[4])) {
227         _PyArg_BadArgument("blobopen", "argument 'name'", "str", args[4]);
228         goto exit;
229     }
230     Py_ssize_t name_length;
231     name = PyUnicode_AsUTF8AndSize(args[4], &name_length);
232     if (name == NULL) {
233         goto exit;
234     }
235     if (strlen(name) != (size_t)name_length) {
236         PyErr_SetString(PyExc_ValueError, "embedded null character");
237         goto exit;
238     }
239 skip_optional_kwonly:
240     return_value = blobopen_impl(self, table, col, row, readonly, name);
241 
242 exit:
243     return return_value;
244 }
245 
246 PyDoc_STRVAR(pysqlite_connection_close__doc__,
247 "close($self, /)\n"
248 "--\n"
249 "\n"
250 "Close the database connection.\n"
251 "\n"
252 "Any pending transaction is not committed implicitly.");
253 
254 #define PYSQLITE_CONNECTION_CLOSE_METHODDEF    \
255     {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS, pysqlite_connection_close__doc__},
256 
257 static PyObject *
258 pysqlite_connection_close_impl(pysqlite_Connection *self);
259 
260 static PyObject *
pysqlite_connection_close(pysqlite_Connection * self,PyObject * Py_UNUSED (ignored))261 pysqlite_connection_close(pysqlite_Connection *self, PyObject *Py_UNUSED(ignored))
262 {
263     return pysqlite_connection_close_impl(self);
264 }
265 
266 PyDoc_STRVAR(pysqlite_connection_commit__doc__,
267 "commit($self, /)\n"
268 "--\n"
269 "\n"
270 "Commit any pending transaction to the database.\n"
271 "\n"
272 "If there is no open transaction, this method is a no-op.");
273 
274 #define PYSQLITE_CONNECTION_COMMIT_METHODDEF    \
275     {"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS, pysqlite_connection_commit__doc__},
276 
277 static PyObject *
278 pysqlite_connection_commit_impl(pysqlite_Connection *self);
279 
280 static PyObject *
pysqlite_connection_commit(pysqlite_Connection * self,PyObject * Py_UNUSED (ignored))281 pysqlite_connection_commit(pysqlite_Connection *self, PyObject *Py_UNUSED(ignored))
282 {
283     return pysqlite_connection_commit_impl(self);
284 }
285 
286 PyDoc_STRVAR(pysqlite_connection_rollback__doc__,
287 "rollback($self, /)\n"
288 "--\n"
289 "\n"
290 "Roll back to the start of any pending transaction.\n"
291 "\n"
292 "If there is no open transaction, this method is a no-op.");
293 
294 #define PYSQLITE_CONNECTION_ROLLBACK_METHODDEF    \
295     {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS, pysqlite_connection_rollback__doc__},
296 
297 static PyObject *
298 pysqlite_connection_rollback_impl(pysqlite_Connection *self);
299 
300 static PyObject *
pysqlite_connection_rollback(pysqlite_Connection * self,PyObject * Py_UNUSED (ignored))301 pysqlite_connection_rollback(pysqlite_Connection *self, PyObject *Py_UNUSED(ignored))
302 {
303     return pysqlite_connection_rollback_impl(self);
304 }
305 
306 PyDoc_STRVAR(pysqlite_connection_create_function__doc__,
307 "create_function($self, /, name, narg, func, *, deterministic=False)\n"
308 "--\n"
309 "\n"
310 "Creates a new function.");
311 
312 #define PYSQLITE_CONNECTION_CREATE_FUNCTION_METHODDEF    \
313     {"create_function", _PyCFunction_CAST(pysqlite_connection_create_function), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_create_function__doc__},
314 
315 static PyObject *
316 pysqlite_connection_create_function_impl(pysqlite_Connection *self,
317                                          PyTypeObject *cls, const char *name,
318                                          int narg, PyObject *func,
319                                          int deterministic);
320 
321 static PyObject *
pysqlite_connection_create_function(pysqlite_Connection * self,PyTypeObject * cls,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)322 pysqlite_connection_create_function(pysqlite_Connection *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
323 {
324     PyObject *return_value = NULL;
325     static const char * const _keywords[] = {"name", "narg", "func", "deterministic", NULL};
326     static _PyArg_Parser _parser = {NULL, _keywords, "create_function", 0};
327     PyObject *argsbuf[4];
328     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
329     const char *name;
330     int narg;
331     PyObject *func;
332     int deterministic = 0;
333 
334     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
335     if (!args) {
336         goto exit;
337     }
338     if (!PyUnicode_Check(args[0])) {
339         _PyArg_BadArgument("create_function", "argument 'name'", "str", args[0]);
340         goto exit;
341     }
342     Py_ssize_t name_length;
343     name = PyUnicode_AsUTF8AndSize(args[0], &name_length);
344     if (name == NULL) {
345         goto exit;
346     }
347     if (strlen(name) != (size_t)name_length) {
348         PyErr_SetString(PyExc_ValueError, "embedded null character");
349         goto exit;
350     }
351     narg = _PyLong_AsInt(args[1]);
352     if (narg == -1 && PyErr_Occurred()) {
353         goto exit;
354     }
355     func = args[2];
356     if (!noptargs) {
357         goto skip_optional_kwonly;
358     }
359     deterministic = PyObject_IsTrue(args[3]);
360     if (deterministic < 0) {
361         goto exit;
362     }
363 skip_optional_kwonly:
364     return_value = pysqlite_connection_create_function_impl(self, cls, name, narg, func, deterministic);
365 
366 exit:
367     return return_value;
368 }
369 
370 #if defined(HAVE_WINDOW_FUNCTIONS)
371 
372 PyDoc_STRVAR(create_window_function__doc__,
373 "create_window_function($self, name, num_params, aggregate_class, /)\n"
374 "--\n"
375 "\n"
376 "Creates or redefines an aggregate window function. Non-standard.\n"
377 "\n"
378 "  name\n"
379 "    The name of the SQL aggregate window function to be created or\n"
380 "    redefined.\n"
381 "  num_params\n"
382 "    The number of arguments the step and inverse methods takes.\n"
383 "  aggregate_class\n"
384 "    A class with step(), finalize(), value(), and inverse() methods.\n"
385 "    Set to None to clear the window function.");
386 
387 #define CREATE_WINDOW_FUNCTION_METHODDEF    \
388     {"create_window_function", _PyCFunction_CAST(create_window_function), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, create_window_function__doc__},
389 
390 static PyObject *
391 create_window_function_impl(pysqlite_Connection *self, PyTypeObject *cls,
392                             const char *name, int num_params,
393                             PyObject *aggregate_class);
394 
395 static PyObject *
create_window_function(pysqlite_Connection * self,PyTypeObject * cls,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)396 create_window_function(pysqlite_Connection *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
397 {
398     PyObject *return_value = NULL;
399     static const char * const _keywords[] = {"", "", "", NULL};
400     static _PyArg_Parser _parser = {NULL, _keywords, "create_window_function", 0};
401     PyObject *argsbuf[3];
402     const char *name;
403     int num_params;
404     PyObject *aggregate_class;
405 
406     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
407     if (!args) {
408         goto exit;
409     }
410     if (!PyUnicode_Check(args[0])) {
411         _PyArg_BadArgument("create_window_function", "argument 1", "str", args[0]);
412         goto exit;
413     }
414     Py_ssize_t name_length;
415     name = PyUnicode_AsUTF8AndSize(args[0], &name_length);
416     if (name == NULL) {
417         goto exit;
418     }
419     if (strlen(name) != (size_t)name_length) {
420         PyErr_SetString(PyExc_ValueError, "embedded null character");
421         goto exit;
422     }
423     num_params = _PyLong_AsInt(args[1]);
424     if (num_params == -1 && PyErr_Occurred()) {
425         goto exit;
426     }
427     aggregate_class = args[2];
428     return_value = create_window_function_impl(self, cls, name, num_params, aggregate_class);
429 
430 exit:
431     return return_value;
432 }
433 
434 #endif /* defined(HAVE_WINDOW_FUNCTIONS) */
435 
436 PyDoc_STRVAR(pysqlite_connection_create_aggregate__doc__,
437 "create_aggregate($self, /, name, n_arg, aggregate_class)\n"
438 "--\n"
439 "\n"
440 "Creates a new aggregate.");
441 
442 #define PYSQLITE_CONNECTION_CREATE_AGGREGATE_METHODDEF    \
443     {"create_aggregate", _PyCFunction_CAST(pysqlite_connection_create_aggregate), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_create_aggregate__doc__},
444 
445 static PyObject *
446 pysqlite_connection_create_aggregate_impl(pysqlite_Connection *self,
447                                           PyTypeObject *cls,
448                                           const char *name, int n_arg,
449                                           PyObject *aggregate_class);
450 
451 static PyObject *
pysqlite_connection_create_aggregate(pysqlite_Connection * self,PyTypeObject * cls,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)452 pysqlite_connection_create_aggregate(pysqlite_Connection *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
453 {
454     PyObject *return_value = NULL;
455     static const char * const _keywords[] = {"name", "n_arg", "aggregate_class", NULL};
456     static _PyArg_Parser _parser = {NULL, _keywords, "create_aggregate", 0};
457     PyObject *argsbuf[3];
458     const char *name;
459     int n_arg;
460     PyObject *aggregate_class;
461 
462     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
463     if (!args) {
464         goto exit;
465     }
466     if (!PyUnicode_Check(args[0])) {
467         _PyArg_BadArgument("create_aggregate", "argument 'name'", "str", args[0]);
468         goto exit;
469     }
470     Py_ssize_t name_length;
471     name = PyUnicode_AsUTF8AndSize(args[0], &name_length);
472     if (name == NULL) {
473         goto exit;
474     }
475     if (strlen(name) != (size_t)name_length) {
476         PyErr_SetString(PyExc_ValueError, "embedded null character");
477         goto exit;
478     }
479     n_arg = _PyLong_AsInt(args[1]);
480     if (n_arg == -1 && PyErr_Occurred()) {
481         goto exit;
482     }
483     aggregate_class = args[2];
484     return_value = pysqlite_connection_create_aggregate_impl(self, cls, name, n_arg, aggregate_class);
485 
486 exit:
487     return return_value;
488 }
489 
490 PyDoc_STRVAR(pysqlite_connection_set_authorizer__doc__,
491 "set_authorizer($self, /, authorizer_callback)\n"
492 "--\n"
493 "\n"
494 "Sets authorizer callback.");
495 
496 #define PYSQLITE_CONNECTION_SET_AUTHORIZER_METHODDEF    \
497     {"set_authorizer", _PyCFunction_CAST(pysqlite_connection_set_authorizer), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_set_authorizer__doc__},
498 
499 static PyObject *
500 pysqlite_connection_set_authorizer_impl(pysqlite_Connection *self,
501                                         PyTypeObject *cls,
502                                         PyObject *callable);
503 
504 static PyObject *
pysqlite_connection_set_authorizer(pysqlite_Connection * self,PyTypeObject * cls,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)505 pysqlite_connection_set_authorizer(pysqlite_Connection *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
506 {
507     PyObject *return_value = NULL;
508     static const char * const _keywords[] = {"authorizer_callback", NULL};
509     static _PyArg_Parser _parser = {NULL, _keywords, "set_authorizer", 0};
510     PyObject *argsbuf[1];
511     PyObject *callable;
512 
513     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
514     if (!args) {
515         goto exit;
516     }
517     callable = args[0];
518     return_value = pysqlite_connection_set_authorizer_impl(self, cls, callable);
519 
520 exit:
521     return return_value;
522 }
523 
524 PyDoc_STRVAR(pysqlite_connection_set_progress_handler__doc__,
525 "set_progress_handler($self, /, progress_handler, n)\n"
526 "--\n"
527 "\n"
528 "Sets progress handler callback.");
529 
530 #define PYSQLITE_CONNECTION_SET_PROGRESS_HANDLER_METHODDEF    \
531     {"set_progress_handler", _PyCFunction_CAST(pysqlite_connection_set_progress_handler), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_set_progress_handler__doc__},
532 
533 static PyObject *
534 pysqlite_connection_set_progress_handler_impl(pysqlite_Connection *self,
535                                               PyTypeObject *cls,
536                                               PyObject *callable, int n);
537 
538 static PyObject *
pysqlite_connection_set_progress_handler(pysqlite_Connection * self,PyTypeObject * cls,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)539 pysqlite_connection_set_progress_handler(pysqlite_Connection *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
540 {
541     PyObject *return_value = NULL;
542     static const char * const _keywords[] = {"progress_handler", "n", NULL};
543     static _PyArg_Parser _parser = {NULL, _keywords, "set_progress_handler", 0};
544     PyObject *argsbuf[2];
545     PyObject *callable;
546     int n;
547 
548     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
549     if (!args) {
550         goto exit;
551     }
552     callable = args[0];
553     n = _PyLong_AsInt(args[1]);
554     if (n == -1 && PyErr_Occurred()) {
555         goto exit;
556     }
557     return_value = pysqlite_connection_set_progress_handler_impl(self, cls, callable, n);
558 
559 exit:
560     return return_value;
561 }
562 
563 PyDoc_STRVAR(pysqlite_connection_set_trace_callback__doc__,
564 "set_trace_callback($self, /, trace_callback)\n"
565 "--\n"
566 "\n"
567 "Sets a trace callback called for each SQL statement (passed as unicode).");
568 
569 #define PYSQLITE_CONNECTION_SET_TRACE_CALLBACK_METHODDEF    \
570     {"set_trace_callback", _PyCFunction_CAST(pysqlite_connection_set_trace_callback), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_set_trace_callback__doc__},
571 
572 static PyObject *
573 pysqlite_connection_set_trace_callback_impl(pysqlite_Connection *self,
574                                             PyTypeObject *cls,
575                                             PyObject *callable);
576 
577 static PyObject *
pysqlite_connection_set_trace_callback(pysqlite_Connection * self,PyTypeObject * cls,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)578 pysqlite_connection_set_trace_callback(pysqlite_Connection *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
579 {
580     PyObject *return_value = NULL;
581     static const char * const _keywords[] = {"trace_callback", NULL};
582     static _PyArg_Parser _parser = {NULL, _keywords, "set_trace_callback", 0};
583     PyObject *argsbuf[1];
584     PyObject *callable;
585 
586     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
587     if (!args) {
588         goto exit;
589     }
590     callable = args[0];
591     return_value = pysqlite_connection_set_trace_callback_impl(self, cls, callable);
592 
593 exit:
594     return return_value;
595 }
596 
597 #if defined(PY_SQLITE_ENABLE_LOAD_EXTENSION)
598 
599 PyDoc_STRVAR(pysqlite_connection_enable_load_extension__doc__,
600 "enable_load_extension($self, enable, /)\n"
601 "--\n"
602 "\n"
603 "Enable dynamic loading of SQLite extension modules.");
604 
605 #define PYSQLITE_CONNECTION_ENABLE_LOAD_EXTENSION_METHODDEF    \
606     {"enable_load_extension", (PyCFunction)pysqlite_connection_enable_load_extension, METH_O, pysqlite_connection_enable_load_extension__doc__},
607 
608 static PyObject *
609 pysqlite_connection_enable_load_extension_impl(pysqlite_Connection *self,
610                                                int onoff);
611 
612 static PyObject *
pysqlite_connection_enable_load_extension(pysqlite_Connection * self,PyObject * arg)613 pysqlite_connection_enable_load_extension(pysqlite_Connection *self, PyObject *arg)
614 {
615     PyObject *return_value = NULL;
616     int onoff;
617 
618     onoff = _PyLong_AsInt(arg);
619     if (onoff == -1 && PyErr_Occurred()) {
620         goto exit;
621     }
622     return_value = pysqlite_connection_enable_load_extension_impl(self, onoff);
623 
624 exit:
625     return return_value;
626 }
627 
628 #endif /* defined(PY_SQLITE_ENABLE_LOAD_EXTENSION) */
629 
630 #if defined(PY_SQLITE_ENABLE_LOAD_EXTENSION)
631 
632 PyDoc_STRVAR(pysqlite_connection_load_extension__doc__,
633 "load_extension($self, name, /)\n"
634 "--\n"
635 "\n"
636 "Load SQLite extension module.");
637 
638 #define PYSQLITE_CONNECTION_LOAD_EXTENSION_METHODDEF    \
639     {"load_extension", (PyCFunction)pysqlite_connection_load_extension, METH_O, pysqlite_connection_load_extension__doc__},
640 
641 static PyObject *
642 pysqlite_connection_load_extension_impl(pysqlite_Connection *self,
643                                         const char *extension_name);
644 
645 static PyObject *
pysqlite_connection_load_extension(pysqlite_Connection * self,PyObject * arg)646 pysqlite_connection_load_extension(pysqlite_Connection *self, PyObject *arg)
647 {
648     PyObject *return_value = NULL;
649     const char *extension_name;
650 
651     if (!PyUnicode_Check(arg)) {
652         _PyArg_BadArgument("load_extension", "argument", "str", arg);
653         goto exit;
654     }
655     Py_ssize_t extension_name_length;
656     extension_name = PyUnicode_AsUTF8AndSize(arg, &extension_name_length);
657     if (extension_name == NULL) {
658         goto exit;
659     }
660     if (strlen(extension_name) != (size_t)extension_name_length) {
661         PyErr_SetString(PyExc_ValueError, "embedded null character");
662         goto exit;
663     }
664     return_value = pysqlite_connection_load_extension_impl(self, extension_name);
665 
666 exit:
667     return return_value;
668 }
669 
670 #endif /* defined(PY_SQLITE_ENABLE_LOAD_EXTENSION) */
671 
672 PyDoc_STRVAR(pysqlite_connection_execute__doc__,
673 "execute($self, sql, parameters=<unrepresentable>, /)\n"
674 "--\n"
675 "\n"
676 "Executes an SQL statement.");
677 
678 #define PYSQLITE_CONNECTION_EXECUTE_METHODDEF    \
679     {"execute", _PyCFunction_CAST(pysqlite_connection_execute), METH_FASTCALL, pysqlite_connection_execute__doc__},
680 
681 static PyObject *
682 pysqlite_connection_execute_impl(pysqlite_Connection *self, PyObject *sql,
683                                  PyObject *parameters);
684 
685 static PyObject *
pysqlite_connection_execute(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs)686 pysqlite_connection_execute(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs)
687 {
688     PyObject *return_value = NULL;
689     PyObject *sql;
690     PyObject *parameters = NULL;
691 
692     if (!_PyArg_CheckPositional("execute", nargs, 1, 2)) {
693         goto exit;
694     }
695     if (!PyUnicode_Check(args[0])) {
696         _PyArg_BadArgument("execute", "argument 1", "str", args[0]);
697         goto exit;
698     }
699     if (PyUnicode_READY(args[0]) == -1) {
700         goto exit;
701     }
702     sql = args[0];
703     if (nargs < 2) {
704         goto skip_optional;
705     }
706     parameters = args[1];
707 skip_optional:
708     return_value = pysqlite_connection_execute_impl(self, sql, parameters);
709 
710 exit:
711     return return_value;
712 }
713 
714 PyDoc_STRVAR(pysqlite_connection_executemany__doc__,
715 "executemany($self, sql, parameters, /)\n"
716 "--\n"
717 "\n"
718 "Repeatedly executes an SQL statement.");
719 
720 #define PYSQLITE_CONNECTION_EXECUTEMANY_METHODDEF    \
721     {"executemany", _PyCFunction_CAST(pysqlite_connection_executemany), METH_FASTCALL, pysqlite_connection_executemany__doc__},
722 
723 static PyObject *
724 pysqlite_connection_executemany_impl(pysqlite_Connection *self,
725                                      PyObject *sql, PyObject *parameters);
726 
727 static PyObject *
pysqlite_connection_executemany(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs)728 pysqlite_connection_executemany(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs)
729 {
730     PyObject *return_value = NULL;
731     PyObject *sql;
732     PyObject *parameters;
733 
734     if (!_PyArg_CheckPositional("executemany", nargs, 2, 2)) {
735         goto exit;
736     }
737     if (!PyUnicode_Check(args[0])) {
738         _PyArg_BadArgument("executemany", "argument 1", "str", args[0]);
739         goto exit;
740     }
741     if (PyUnicode_READY(args[0]) == -1) {
742         goto exit;
743     }
744     sql = args[0];
745     parameters = args[1];
746     return_value = pysqlite_connection_executemany_impl(self, sql, parameters);
747 
748 exit:
749     return return_value;
750 }
751 
752 PyDoc_STRVAR(pysqlite_connection_executescript__doc__,
753 "executescript($self, sql_script, /)\n"
754 "--\n"
755 "\n"
756 "Executes multiple SQL statements at once.");
757 
758 #define PYSQLITE_CONNECTION_EXECUTESCRIPT_METHODDEF    \
759     {"executescript", (PyCFunction)pysqlite_connection_executescript, METH_O, pysqlite_connection_executescript__doc__},
760 
761 PyDoc_STRVAR(pysqlite_connection_interrupt__doc__,
762 "interrupt($self, /)\n"
763 "--\n"
764 "\n"
765 "Abort any pending database operation.");
766 
767 #define PYSQLITE_CONNECTION_INTERRUPT_METHODDEF    \
768     {"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS, pysqlite_connection_interrupt__doc__},
769 
770 static PyObject *
771 pysqlite_connection_interrupt_impl(pysqlite_Connection *self);
772 
773 static PyObject *
pysqlite_connection_interrupt(pysqlite_Connection * self,PyObject * Py_UNUSED (ignored))774 pysqlite_connection_interrupt(pysqlite_Connection *self, PyObject *Py_UNUSED(ignored))
775 {
776     return pysqlite_connection_interrupt_impl(self);
777 }
778 
779 PyDoc_STRVAR(pysqlite_connection_iterdump__doc__,
780 "iterdump($self, /)\n"
781 "--\n"
782 "\n"
783 "Returns iterator to the dump of the database in an SQL text format.");
784 
785 #define PYSQLITE_CONNECTION_ITERDUMP_METHODDEF    \
786     {"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS, pysqlite_connection_iterdump__doc__},
787 
788 static PyObject *
789 pysqlite_connection_iterdump_impl(pysqlite_Connection *self);
790 
791 static PyObject *
pysqlite_connection_iterdump(pysqlite_Connection * self,PyObject * Py_UNUSED (ignored))792 pysqlite_connection_iterdump(pysqlite_Connection *self, PyObject *Py_UNUSED(ignored))
793 {
794     return pysqlite_connection_iterdump_impl(self);
795 }
796 
797 PyDoc_STRVAR(pysqlite_connection_backup__doc__,
798 "backup($self, /, target, *, pages=-1, progress=None, name=\'main\',\n"
799 "       sleep=0.25)\n"
800 "--\n"
801 "\n"
802 "Makes a backup of the database.");
803 
804 #define PYSQLITE_CONNECTION_BACKUP_METHODDEF    \
805     {"backup", _PyCFunction_CAST(pysqlite_connection_backup), METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_backup__doc__},
806 
807 static PyObject *
808 pysqlite_connection_backup_impl(pysqlite_Connection *self,
809                                 pysqlite_Connection *target, int pages,
810                                 PyObject *progress, const char *name,
811                                 double sleep);
812 
813 static PyObject *
pysqlite_connection_backup(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)814 pysqlite_connection_backup(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
815 {
816     PyObject *return_value = NULL;
817     static const char * const _keywords[] = {"target", "pages", "progress", "name", "sleep", NULL};
818     static _PyArg_Parser _parser = {NULL, _keywords, "backup", 0};
819     PyObject *argsbuf[5];
820     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
821     pysqlite_Connection *target;
822     int pages = -1;
823     PyObject *progress = Py_None;
824     const char *name = "main";
825     double sleep = 0.25;
826 
827     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
828     if (!args) {
829         goto exit;
830     }
831     if (!PyObject_TypeCheck(args[0], clinic_state()->ConnectionType)) {
832         _PyArg_BadArgument("backup", "argument 'target'", (clinic_state()->ConnectionType)->tp_name, args[0]);
833         goto exit;
834     }
835     target = (pysqlite_Connection *)args[0];
836     if (!noptargs) {
837         goto skip_optional_kwonly;
838     }
839     if (args[1]) {
840         pages = _PyLong_AsInt(args[1]);
841         if (pages == -1 && PyErr_Occurred()) {
842             goto exit;
843         }
844         if (!--noptargs) {
845             goto skip_optional_kwonly;
846         }
847     }
848     if (args[2]) {
849         progress = args[2];
850         if (!--noptargs) {
851             goto skip_optional_kwonly;
852         }
853     }
854     if (args[3]) {
855         if (!PyUnicode_Check(args[3])) {
856             _PyArg_BadArgument("backup", "argument 'name'", "str", args[3]);
857             goto exit;
858         }
859         Py_ssize_t name_length;
860         name = PyUnicode_AsUTF8AndSize(args[3], &name_length);
861         if (name == NULL) {
862             goto exit;
863         }
864         if (strlen(name) != (size_t)name_length) {
865             PyErr_SetString(PyExc_ValueError, "embedded null character");
866             goto exit;
867         }
868         if (!--noptargs) {
869             goto skip_optional_kwonly;
870         }
871     }
872     if (PyFloat_CheckExact(args[4])) {
873         sleep = PyFloat_AS_DOUBLE(args[4]);
874     }
875     else
876     {
877         sleep = PyFloat_AsDouble(args[4]);
878         if (sleep == -1.0 && PyErr_Occurred()) {
879             goto exit;
880         }
881     }
882 skip_optional_kwonly:
883     return_value = pysqlite_connection_backup_impl(self, target, pages, progress, name, sleep);
884 
885 exit:
886     return return_value;
887 }
888 
889 PyDoc_STRVAR(pysqlite_connection_create_collation__doc__,
890 "create_collation($self, name, callback, /)\n"
891 "--\n"
892 "\n"
893 "Creates a collation function.");
894 
895 #define PYSQLITE_CONNECTION_CREATE_COLLATION_METHODDEF    \
896     {"create_collation", _PyCFunction_CAST(pysqlite_connection_create_collation), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, pysqlite_connection_create_collation__doc__},
897 
898 static PyObject *
899 pysqlite_connection_create_collation_impl(pysqlite_Connection *self,
900                                           PyTypeObject *cls,
901                                           const char *name,
902                                           PyObject *callable);
903 
904 static PyObject *
pysqlite_connection_create_collation(pysqlite_Connection * self,PyTypeObject * cls,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)905 pysqlite_connection_create_collation(pysqlite_Connection *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
906 {
907     PyObject *return_value = NULL;
908     static const char * const _keywords[] = {"", "", NULL};
909     static _PyArg_Parser _parser = {NULL, _keywords, "create_collation", 0};
910     PyObject *argsbuf[2];
911     const char *name;
912     PyObject *callable;
913 
914     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
915     if (!args) {
916         goto exit;
917     }
918     if (!PyUnicode_Check(args[0])) {
919         _PyArg_BadArgument("create_collation", "argument 1", "str", args[0]);
920         goto exit;
921     }
922     Py_ssize_t name_length;
923     name = PyUnicode_AsUTF8AndSize(args[0], &name_length);
924     if (name == NULL) {
925         goto exit;
926     }
927     if (strlen(name) != (size_t)name_length) {
928         PyErr_SetString(PyExc_ValueError, "embedded null character");
929         goto exit;
930     }
931     callable = args[1];
932     return_value = pysqlite_connection_create_collation_impl(self, cls, name, callable);
933 
934 exit:
935     return return_value;
936 }
937 
938 #if defined(PY_SQLITE_HAVE_SERIALIZE)
939 
940 PyDoc_STRVAR(serialize__doc__,
941 "serialize($self, /, *, name=\'main\')\n"
942 "--\n"
943 "\n"
944 "Serialize a database into a byte string.\n"
945 "\n"
946 "  name\n"
947 "    Which database to serialize.\n"
948 "\n"
949 "For an ordinary on-disk database file, the serialization is just a copy of the\n"
950 "disk file. For an in-memory database or a \"temp\" database, the serialization is\n"
951 "the same sequence of bytes which would be written to disk if that database\n"
952 "were backed up to disk.");
953 
954 #define SERIALIZE_METHODDEF    \
955     {"serialize", _PyCFunction_CAST(serialize), METH_FASTCALL|METH_KEYWORDS, serialize__doc__},
956 
957 static PyObject *
958 serialize_impl(pysqlite_Connection *self, const char *name);
959 
960 static PyObject *
serialize(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)961 serialize(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
962 {
963     PyObject *return_value = NULL;
964     static const char * const _keywords[] = {"name", NULL};
965     static _PyArg_Parser _parser = {NULL, _keywords, "serialize", 0};
966     PyObject *argsbuf[1];
967     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
968     const char *name = "main";
969 
970     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
971     if (!args) {
972         goto exit;
973     }
974     if (!noptargs) {
975         goto skip_optional_kwonly;
976     }
977     if (!PyUnicode_Check(args[0])) {
978         _PyArg_BadArgument("serialize", "argument 'name'", "str", args[0]);
979         goto exit;
980     }
981     Py_ssize_t name_length;
982     name = PyUnicode_AsUTF8AndSize(args[0], &name_length);
983     if (name == NULL) {
984         goto exit;
985     }
986     if (strlen(name) != (size_t)name_length) {
987         PyErr_SetString(PyExc_ValueError, "embedded null character");
988         goto exit;
989     }
990 skip_optional_kwonly:
991     return_value = serialize_impl(self, name);
992 
993 exit:
994     return return_value;
995 }
996 
997 #endif /* defined(PY_SQLITE_HAVE_SERIALIZE) */
998 
999 #if defined(PY_SQLITE_HAVE_SERIALIZE)
1000 
1001 PyDoc_STRVAR(deserialize__doc__,
1002 "deserialize($self, data, /, *, name=\'main\')\n"
1003 "--\n"
1004 "\n"
1005 "Load a serialized database.\n"
1006 "\n"
1007 "  data\n"
1008 "    The serialized database content.\n"
1009 "  name\n"
1010 "    Which database to reopen with the deserialization.\n"
1011 "\n"
1012 "The deserialize interface causes the database connection to disconnect from the\n"
1013 "target database, and then reopen it as an in-memory database based on the given\n"
1014 "serialized data.\n"
1015 "\n"
1016 "The deserialize interface will fail with SQLITE_BUSY if the database is\n"
1017 "currently in a read transaction or is involved in a backup operation.");
1018 
1019 #define DESERIALIZE_METHODDEF    \
1020     {"deserialize", _PyCFunction_CAST(deserialize), METH_FASTCALL|METH_KEYWORDS, deserialize__doc__},
1021 
1022 static PyObject *
1023 deserialize_impl(pysqlite_Connection *self, Py_buffer *data,
1024                  const char *name);
1025 
1026 static PyObject *
deserialize(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)1027 deserialize(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1028 {
1029     PyObject *return_value = NULL;
1030     static const char * const _keywords[] = {"", "name", NULL};
1031     static _PyArg_Parser _parser = {NULL, _keywords, "deserialize", 0};
1032     PyObject *argsbuf[2];
1033     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1034     Py_buffer data = {NULL, NULL};
1035     const char *name = "main";
1036 
1037     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
1038     if (!args) {
1039         goto exit;
1040     }
1041     if (PyUnicode_Check(args[0])) {
1042         Py_ssize_t len;
1043         const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
1044         if (ptr == NULL) {
1045             goto exit;
1046         }
1047         PyBuffer_FillInfo(&data, args[0], (void *)ptr, len, 1, 0);
1048     }
1049     else { /* any bytes-like object */
1050         if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1051             goto exit;
1052         }
1053         if (!PyBuffer_IsContiguous(&data, 'C')) {
1054             _PyArg_BadArgument("deserialize", "argument 1", "contiguous buffer", args[0]);
1055             goto exit;
1056         }
1057     }
1058     if (!noptargs) {
1059         goto skip_optional_kwonly;
1060     }
1061     if (!PyUnicode_Check(args[1])) {
1062         _PyArg_BadArgument("deserialize", "argument 'name'", "str", args[1]);
1063         goto exit;
1064     }
1065     Py_ssize_t name_length;
1066     name = PyUnicode_AsUTF8AndSize(args[1], &name_length);
1067     if (name == NULL) {
1068         goto exit;
1069     }
1070     if (strlen(name) != (size_t)name_length) {
1071         PyErr_SetString(PyExc_ValueError, "embedded null character");
1072         goto exit;
1073     }
1074 skip_optional_kwonly:
1075     return_value = deserialize_impl(self, &data, name);
1076 
1077 exit:
1078     /* Cleanup for data */
1079     if (data.obj) {
1080        PyBuffer_Release(&data);
1081     }
1082 
1083     return return_value;
1084 }
1085 
1086 #endif /* defined(PY_SQLITE_HAVE_SERIALIZE) */
1087 
1088 PyDoc_STRVAR(pysqlite_connection_enter__doc__,
1089 "__enter__($self, /)\n"
1090 "--\n"
1091 "\n"
1092 "Called when the connection is used as a context manager.\n"
1093 "\n"
1094 "Returns itself as a convenience to the caller.");
1095 
1096 #define PYSQLITE_CONNECTION_ENTER_METHODDEF    \
1097     {"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS, pysqlite_connection_enter__doc__},
1098 
1099 static PyObject *
1100 pysqlite_connection_enter_impl(pysqlite_Connection *self);
1101 
1102 static PyObject *
pysqlite_connection_enter(pysqlite_Connection * self,PyObject * Py_UNUSED (ignored))1103 pysqlite_connection_enter(pysqlite_Connection *self, PyObject *Py_UNUSED(ignored))
1104 {
1105     return pysqlite_connection_enter_impl(self);
1106 }
1107 
1108 PyDoc_STRVAR(pysqlite_connection_exit__doc__,
1109 "__exit__($self, type, value, traceback, /)\n"
1110 "--\n"
1111 "\n"
1112 "Called when the connection is used as a context manager.\n"
1113 "\n"
1114 "If there was any exception, a rollback takes place; otherwise we commit.");
1115 
1116 #define PYSQLITE_CONNECTION_EXIT_METHODDEF    \
1117     {"__exit__", _PyCFunction_CAST(pysqlite_connection_exit), METH_FASTCALL, pysqlite_connection_exit__doc__},
1118 
1119 static PyObject *
1120 pysqlite_connection_exit_impl(pysqlite_Connection *self, PyObject *exc_type,
1121                               PyObject *exc_value, PyObject *exc_tb);
1122 
1123 static PyObject *
pysqlite_connection_exit(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs)1124 pysqlite_connection_exit(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs)
1125 {
1126     PyObject *return_value = NULL;
1127     PyObject *exc_type;
1128     PyObject *exc_value;
1129     PyObject *exc_tb;
1130 
1131     if (!_PyArg_CheckPositional("__exit__", nargs, 3, 3)) {
1132         goto exit;
1133     }
1134     exc_type = args[0];
1135     exc_value = args[1];
1136     exc_tb = args[2];
1137     return_value = pysqlite_connection_exit_impl(self, exc_type, exc_value, exc_tb);
1138 
1139 exit:
1140     return return_value;
1141 }
1142 
1143 PyDoc_STRVAR(setlimit__doc__,
1144 "setlimit($self, category, limit, /)\n"
1145 "--\n"
1146 "\n"
1147 "Set connection run-time limits.\n"
1148 "\n"
1149 "  category\n"
1150 "    The limit category to be set.\n"
1151 "  limit\n"
1152 "    The new limit. If the new limit is a negative number, the limit is\n"
1153 "    unchanged.\n"
1154 "\n"
1155 "Attempts to increase a limit above its hard upper bound are silently truncated\n"
1156 "to the hard upper bound. Regardless of whether or not the limit was changed,\n"
1157 "the prior value of the limit is returned.");
1158 
1159 #define SETLIMIT_METHODDEF    \
1160     {"setlimit", _PyCFunction_CAST(setlimit), METH_FASTCALL, setlimit__doc__},
1161 
1162 static PyObject *
1163 setlimit_impl(pysqlite_Connection *self, int category, int limit);
1164 
1165 static PyObject *
setlimit(pysqlite_Connection * self,PyObject * const * args,Py_ssize_t nargs)1166 setlimit(pysqlite_Connection *self, PyObject *const *args, Py_ssize_t nargs)
1167 {
1168     PyObject *return_value = NULL;
1169     int category;
1170     int limit;
1171 
1172     if (!_PyArg_CheckPositional("setlimit", nargs, 2, 2)) {
1173         goto exit;
1174     }
1175     category = _PyLong_AsInt(args[0]);
1176     if (category == -1 && PyErr_Occurred()) {
1177         goto exit;
1178     }
1179     limit = _PyLong_AsInt(args[1]);
1180     if (limit == -1 && PyErr_Occurred()) {
1181         goto exit;
1182     }
1183     return_value = setlimit_impl(self, category, limit);
1184 
1185 exit:
1186     return return_value;
1187 }
1188 
1189 PyDoc_STRVAR(getlimit__doc__,
1190 "getlimit($self, category, /)\n"
1191 "--\n"
1192 "\n"
1193 "Get connection run-time limits.\n"
1194 "\n"
1195 "  category\n"
1196 "    The limit category to be queried.");
1197 
1198 #define GETLIMIT_METHODDEF    \
1199     {"getlimit", (PyCFunction)getlimit, METH_O, getlimit__doc__},
1200 
1201 static PyObject *
1202 getlimit_impl(pysqlite_Connection *self, int category);
1203 
1204 static PyObject *
getlimit(pysqlite_Connection * self,PyObject * arg)1205 getlimit(pysqlite_Connection *self, PyObject *arg)
1206 {
1207     PyObject *return_value = NULL;
1208     int category;
1209 
1210     category = _PyLong_AsInt(arg);
1211     if (category == -1 && PyErr_Occurred()) {
1212         goto exit;
1213     }
1214     return_value = getlimit_impl(self, category);
1215 
1216 exit:
1217     return return_value;
1218 }
1219 
1220 #ifndef CREATE_WINDOW_FUNCTION_METHODDEF
1221     #define CREATE_WINDOW_FUNCTION_METHODDEF
1222 #endif /* !defined(CREATE_WINDOW_FUNCTION_METHODDEF) */
1223 
1224 #ifndef PYSQLITE_CONNECTION_ENABLE_LOAD_EXTENSION_METHODDEF
1225     #define PYSQLITE_CONNECTION_ENABLE_LOAD_EXTENSION_METHODDEF
1226 #endif /* !defined(PYSQLITE_CONNECTION_ENABLE_LOAD_EXTENSION_METHODDEF) */
1227 
1228 #ifndef PYSQLITE_CONNECTION_LOAD_EXTENSION_METHODDEF
1229     #define PYSQLITE_CONNECTION_LOAD_EXTENSION_METHODDEF
1230 #endif /* !defined(PYSQLITE_CONNECTION_LOAD_EXTENSION_METHODDEF) */
1231 
1232 #ifndef SERIALIZE_METHODDEF
1233     #define SERIALIZE_METHODDEF
1234 #endif /* !defined(SERIALIZE_METHODDEF) */
1235 
1236 #ifndef DESERIALIZE_METHODDEF
1237     #define DESERIALIZE_METHODDEF
1238 #endif /* !defined(DESERIALIZE_METHODDEF) */
1239 /*[clinic end generated code: output=67e5b3dbade4a15b input=a9049054013a1b77]*/
1240