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