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