Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(pysqlite_connect__doc__,
6 : : "connect($module, /, database, timeout=5.0, detect_types=0,\n"
7 : : " isolation_level=<unrepresentable>, check_same_thread=True,\n"
8 : : " factory=ConnectionType, cached_statements=128, uri=False)\n"
9 : : "--\n"
10 : : "\n"
11 : : "Opens a connection to the SQLite database file database.\n"
12 : : "\n"
13 : : "You can use \":memory:\" to open a database connection to a database that resides\n"
14 : : "in RAM instead of on disk.");
15 : :
16 : : #define PYSQLITE_CONNECT_METHODDEF \
17 : : {"connect", _PyCFunction_CAST(pysqlite_connect), METH_FASTCALL|METH_KEYWORDS, pysqlite_connect__doc__},
18 : :
19 : : static PyObject *
20 : : pysqlite_connect_impl(PyObject *module, PyObject *database, double timeout,
21 : : int detect_types, PyObject *isolation_level,
22 : : int check_same_thread, PyObject *factory,
23 : : int cached_statements, int uri);
24 : :
25 : : static PyObject *
26 : 502 : pysqlite_connect(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
27 : : {
28 : 502 : PyObject *return_value = NULL;
29 : : static const char * const _keywords[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", "uri", NULL};
30 : : static _PyArg_Parser _parser = {NULL, _keywords, "connect", 0};
31 : : PyObject *argsbuf[8];
32 [ + + ]: 502 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
33 : : PyObject *database;
34 : 502 : double timeout = 5.0;
35 : 502 : int detect_types = 0;
36 : 502 : PyObject *isolation_level = NULL;
37 : 502 : int check_same_thread = 1;
38 : 502 : PyObject *factory = (PyObject*)clinic_state()->ConnectionType;
39 : 502 : int cached_statements = 128;
40 : 502 : int uri = 0;
41 : :
42 [ + + + - : 502 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 8, 0, argsbuf);
+ - - + ]
43 [ - + ]: 502 : if (!args) {
44 : 0 : goto exit;
45 : : }
46 : 502 : database = args[0];
47 [ + + ]: 502 : if (!noptargs) {
48 : 413 : goto skip_optional_pos;
49 : : }
50 [ + + ]: 89 : if (args[1]) {
51 [ + - ]: 22 : if (PyFloat_CheckExact(args[1])) {
52 : 22 : timeout = PyFloat_AS_DOUBLE(args[1]);
53 : : }
54 : : else
55 : : {
56 : 0 : timeout = PyFloat_AsDouble(args[1]);
57 [ # # # # ]: 0 : if (timeout == -1.0 && PyErr_Occurred()) {
58 : 0 : goto exit;
59 : : }
60 : : }
61 [ + - ]: 22 : if (!--noptargs) {
62 : 22 : goto skip_optional_pos;
63 : : }
64 : : }
65 [ + + ]: 67 : if (args[2]) {
66 : 33 : detect_types = _PyLong_AsInt(args[2]);
67 [ - + - - ]: 33 : if (detect_types == -1 && PyErr_Occurred()) {
68 : 0 : goto exit;
69 : : }
70 [ + - ]: 33 : if (!--noptargs) {
71 : 33 : goto skip_optional_pos;
72 : : }
73 : : }
74 [ + + ]: 34 : if (args[3]) {
75 : 21 : isolation_level = args[3];
76 [ + - ]: 21 : if (!--noptargs) {
77 : 21 : goto skip_optional_pos;
78 : : }
79 : : }
80 [ + + ]: 13 : if (args[4]) {
81 : 1 : check_same_thread = _PyLong_AsInt(args[4]);
82 [ - + - - ]: 1 : if (check_same_thread == -1 && PyErr_Occurred()) {
83 : 0 : goto exit;
84 : : }
85 [ + - ]: 1 : if (!--noptargs) {
86 : 1 : goto skip_optional_pos;
87 : : }
88 : : }
89 [ + + ]: 12 : if (args[5]) {
90 : 6 : factory = args[5];
91 [ + - ]: 6 : if (!--noptargs) {
92 : 6 : goto skip_optional_pos;
93 : : }
94 : : }
95 [ + + ]: 6 : if (args[6]) {
96 : 1 : cached_statements = _PyLong_AsInt(args[6]);
97 [ - + - - ]: 1 : if (cached_statements == -1 && PyErr_Occurred()) {
98 : 0 : goto exit;
99 : : }
100 [ + - ]: 1 : if (!--noptargs) {
101 : 1 : goto skip_optional_pos;
102 : : }
103 : : }
104 : 5 : uri = PyObject_IsTrue(args[7]);
105 [ - + ]: 5 : if (uri < 0) {
106 : 0 : goto exit;
107 : : }
108 : 5 : skip_optional_pos:
109 : 502 : return_value = pysqlite_connect_impl(module, database, timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements, uri);
110 : :
111 : 502 : exit:
112 : 502 : return return_value;
113 : : }
114 : :
115 : : PyDoc_STRVAR(pysqlite_complete_statement__doc__,
116 : : "complete_statement($module, /, statement)\n"
117 : : "--\n"
118 : : "\n"
119 : : "Checks if a string contains a complete SQL statement.");
120 : :
121 : : #define PYSQLITE_COMPLETE_STATEMENT_METHODDEF \
122 : : {"complete_statement", _PyCFunction_CAST(pysqlite_complete_statement), METH_FASTCALL|METH_KEYWORDS, pysqlite_complete_statement__doc__},
123 : :
124 : : static PyObject *
125 : : pysqlite_complete_statement_impl(PyObject *module, const char *statement);
126 : :
127 : : static PyObject *
128 : 2 : pysqlite_complete_statement(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
129 : : {
130 : 2 : PyObject *return_value = NULL;
131 : : static const char * const _keywords[] = {"statement", NULL};
132 : : static _PyArg_Parser _parser = {NULL, _keywords, "complete_statement", 0};
133 : : PyObject *argsbuf[1];
134 : : const char *statement;
135 : :
136 [ + - + - : 2 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
137 [ - + ]: 2 : if (!args) {
138 : 0 : goto exit;
139 : : }
140 [ - + ]: 2 : if (!PyUnicode_Check(args[0])) {
141 : 0 : _PyArg_BadArgument("complete_statement", "argument 'statement'", "str", args[0]);
142 : 0 : goto exit;
143 : : }
144 : : Py_ssize_t statement_length;
145 : 2 : statement = PyUnicode_AsUTF8AndSize(args[0], &statement_length);
146 [ - + ]: 2 : if (statement == NULL) {
147 : 0 : goto exit;
148 : : }
149 [ - + ]: 2 : if (strlen(statement) != (size_t)statement_length) {
150 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
151 : 0 : goto exit;
152 : : }
153 : 2 : return_value = pysqlite_complete_statement_impl(module, statement);
154 : :
155 : 2 : exit:
156 : 2 : return return_value;
157 : : }
158 : :
159 : : PyDoc_STRVAR(pysqlite_register_adapter__doc__,
160 : : "register_adapter($module, type, adapter, /)\n"
161 : : "--\n"
162 : : "\n"
163 : : "Register a function to adapt Python objects to SQLite values.");
164 : :
165 : : #define PYSQLITE_REGISTER_ADAPTER_METHODDEF \
166 : : {"register_adapter", _PyCFunction_CAST(pysqlite_register_adapter), METH_FASTCALL, pysqlite_register_adapter__doc__},
167 : :
168 : : static PyObject *
169 : : pysqlite_register_adapter_impl(PyObject *module, PyTypeObject *type,
170 : : PyObject *caster);
171 : :
172 : : static PyObject *
173 : 17 : pysqlite_register_adapter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
174 : : {
175 : 17 : PyObject *return_value = NULL;
176 : : PyTypeObject *type;
177 : : PyObject *caster;
178 : :
179 [ + - - + : 17 : if (!_PyArg_CheckPositional("register_adapter", nargs, 2, 2)) {
- - ]
180 : 0 : goto exit;
181 : : }
182 : 17 : type = (PyTypeObject *)args[0];
183 : 17 : caster = args[1];
184 : 17 : return_value = pysqlite_register_adapter_impl(module, type, caster);
185 : :
186 : 17 : exit:
187 : 17 : return return_value;
188 : : }
189 : :
190 : : PyDoc_STRVAR(pysqlite_register_converter__doc__,
191 : : "register_converter($module, typename, converter, /)\n"
192 : : "--\n"
193 : : "\n"
194 : : "Register a function to convert SQLite values to Python objects.");
195 : :
196 : : #define PYSQLITE_REGISTER_CONVERTER_METHODDEF \
197 : : {"register_converter", _PyCFunction_CAST(pysqlite_register_converter), METH_FASTCALL, pysqlite_register_converter__doc__},
198 : :
199 : : static PyObject *
200 : : pysqlite_register_converter_impl(PyObject *module, PyObject *orig_name,
201 : : PyObject *callable);
202 : :
203 : : static PyObject *
204 : 9 : pysqlite_register_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
205 : : {
206 : 9 : PyObject *return_value = NULL;
207 : : PyObject *orig_name;
208 : : PyObject *callable;
209 : :
210 [ + - - + : 9 : if (!_PyArg_CheckPositional("register_converter", nargs, 2, 2)) {
- - ]
211 : 0 : goto exit;
212 : : }
213 [ - + ]: 9 : if (!PyUnicode_Check(args[0])) {
214 : 0 : _PyArg_BadArgument("register_converter", "argument 1", "str", args[0]);
215 : 0 : goto exit;
216 : : }
217 [ - + ]: 9 : if (PyUnicode_READY(args[0]) == -1) {
218 : 0 : goto exit;
219 : : }
220 : 9 : orig_name = args[0];
221 : 9 : callable = args[1];
222 : 9 : return_value = pysqlite_register_converter_impl(module, orig_name, callable);
223 : :
224 : 9 : exit:
225 : 9 : return return_value;
226 : : }
227 : :
228 : : PyDoc_STRVAR(pysqlite_enable_callback_trace__doc__,
229 : : "enable_callback_tracebacks($module, enable, /)\n"
230 : : "--\n"
231 : : "\n"
232 : : "Enable or disable callback functions throwing errors to stderr.");
233 : :
234 : : #define PYSQLITE_ENABLE_CALLBACK_TRACE_METHODDEF \
235 : : {"enable_callback_tracebacks", (PyCFunction)pysqlite_enable_callback_trace, METH_O, pysqlite_enable_callback_trace__doc__},
236 : :
237 : : static PyObject *
238 : : pysqlite_enable_callback_trace_impl(PyObject *module, int enable);
239 : :
240 : : static PyObject *
241 : 40 : pysqlite_enable_callback_trace(PyObject *module, PyObject *arg)
242 : : {
243 : 40 : PyObject *return_value = NULL;
244 : : int enable;
245 : :
246 : 40 : enable = _PyLong_AsInt(arg);
247 [ - + - - ]: 40 : if (enable == -1 && PyErr_Occurred()) {
248 : 0 : goto exit;
249 : : }
250 : 40 : return_value = pysqlite_enable_callback_trace_impl(module, enable);
251 : :
252 : 40 : exit:
253 : 40 : return return_value;
254 : : }
255 : :
256 : : PyDoc_STRVAR(pysqlite_adapt__doc__,
257 : : "adapt($module, obj, proto=PrepareProtocolType, alt=<unrepresentable>, /)\n"
258 : : "--\n"
259 : : "\n"
260 : : "Adapt given object to given protocol.");
261 : :
262 : : #define PYSQLITE_ADAPT_METHODDEF \
263 : : {"adapt", _PyCFunction_CAST(pysqlite_adapt), METH_FASTCALL, pysqlite_adapt__doc__},
264 : :
265 : : static PyObject *
266 : : pysqlite_adapt_impl(PyObject *module, PyObject *obj, PyObject *proto,
267 : : PyObject *alt);
268 : :
269 : : static PyObject *
270 : 7 : pysqlite_adapt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
271 : : {
272 : 7 : PyObject *return_value = NULL;
273 : : PyObject *obj;
274 : 7 : PyObject *proto = (PyObject *)clinic_state()->PrepareProtocolType;
275 : 7 : PyObject *alt = NULL;
276 : :
277 [ + - - + : 7 : if (!_PyArg_CheckPositional("adapt", nargs, 1, 3)) {
- - ]
278 : 0 : goto exit;
279 : : }
280 : 7 : obj = args[0];
281 [ + + ]: 7 : if (nargs < 2) {
282 : 3 : goto skip_optional;
283 : : }
284 : 4 : proto = args[1];
285 [ + + ]: 4 : if (nargs < 3) {
286 : 3 : goto skip_optional;
287 : : }
288 : 1 : alt = args[2];
289 : 7 : skip_optional:
290 : 7 : return_value = pysqlite_adapt_impl(module, obj, proto, alt);
291 : :
292 : 7 : exit:
293 : 7 : return return_value;
294 : : }
295 : : /*[clinic end generated code: output=9ac18606b0eaec03 input=a9049054013a1b77]*/
|
