1 /* module.c - the module itself
3 * Copyright (C) 2004-2007 Gerhard Häring <gh@ghaering.de>
5 * This file is part of pysqlite.
7 * This software is provided 'as-is', without any express or implied
8 * warranty. In no event will the authors be held liable for any damages
9 * arising from the use of this software.
11 * Permission is granted to anyone to use this software for any purpose,
12 * including commercial applications, and to alter it and redistribute it
13 * freely, subject to the following restrictions:
15 * 1. The origin of this software must not be misrepresented; you must not
16 * claim that you wrote the original software. If you use this software
17 * in a product, an acknowledgment in the product documentation would be
18 * appreciated but is not required.
19 * 2. Altered source versions must be plainly marked as such, and must not be
20 * misrepresented as being the original software.
21 * 3. This notice may not be removed or altered from any source distribution.
24 #include "connection.h"
25 #include "statement.h"
28 #include "prepare_protocol.h"
29 #include "microprotocols.h"
32 #if SQLITE_VERSION_NUMBER >= 3003003
33 #define HAVE_SHARED_CACHE
36 /* static objects at module-level */
38 PyObject
* pysqlite_Error
, *pysqlite_Warning
, *pysqlite_InterfaceError
, *pysqlite_DatabaseError
,
39 *pysqlite_InternalError
, *pysqlite_OperationalError
, *pysqlite_ProgrammingError
,
40 *pysqlite_IntegrityError
, *pysqlite_DataError
, *pysqlite_NotSupportedError
, *pysqlite_OptimizedUnicode
;
43 int _enable_callback_tracebacks
;
44 int pysqlite_BaseTypeAdapted
;
46 static PyObject
* module_connect(PyObject
* self
, PyObject
* args
, PyObject
*
49 /* Python seems to have no way of extracting a single keyword-arg at
50 * C-level, so this code is redundant with the one in connection_init in
51 * connection.c and must always be copied from there ... */
53 static char *kwlist
[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", NULL
, NULL
};
56 PyObject
* isolation_level
;
57 PyObject
* factory
= NULL
;
58 int check_same_thread
= 1;
59 int cached_statements
;
64 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "O|diOiOi", kwlist
,
65 &database
, &timeout
, &detect_types
, &isolation_level
, &check_same_thread
, &factory
, &cached_statements
))
70 if (factory
== NULL
) {
71 factory
= (PyObject
*)&pysqlite_ConnectionType
;
74 result
= PyObject_Call(factory
, args
, kwargs
);
79 static PyObject
* module_complete(PyObject
* self
, PyObject
* args
, PyObject
*
82 static char *kwlist
[] = {"statement", NULL
, NULL
};
87 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s", kwlist
, &statement
))
92 if (sqlite3_complete(statement
)) {
103 #ifdef HAVE_SHARED_CACHE
104 static PyObject
* module_enable_shared_cache(PyObject
* self
, PyObject
* args
, PyObject
*
107 static char *kwlist
[] = {"do_enable", NULL
, NULL
};
111 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "i", kwlist
, &do_enable
))
116 rc
= sqlite3_enable_shared_cache(do_enable
);
118 if (rc
!= SQLITE_OK
) {
119 PyErr_SetString(pysqlite_OperationalError
, "Changing the shared_cache flag failed");
126 #endif /* HAVE_SHARED_CACHE */
128 static PyObject
* module_register_adapter(PyObject
* self
, PyObject
* args
, PyObject
* kwargs
)
133 if (!PyArg_ParseTuple(args
, "OO", &type
, &caster
)) {
137 /* a basic type is adapted; there's a performance optimization if that's not the case
138 * (99 % of all usages) */
139 if (type
== &PyInt_Type
|| type
== &PyLong_Type
|| type
== &PyFloat_Type
140 || type
== &PyString_Type
|| type
== &PyUnicode_Type
|| type
== &PyBuffer_Type
) {
141 pysqlite_BaseTypeAdapted
= 1;
144 microprotocols_add(type
, (PyObject
*)&pysqlite_PrepareProtocolType
, caster
);
150 static PyObject
* module_register_converter(PyObject
* self
, PyObject
* args
, PyObject
* kwargs
)
153 PyObject
* name
= NULL
;
155 PyObject
* retval
= NULL
;
157 if (!PyArg_ParseTuple(args
, "SO", &orig_name
, &callable
)) {
161 /* convert the name to upper case */
162 name
= PyObject_CallMethod(orig_name
, "upper", "");
167 if (PyDict_SetItem(converters
, name
, callable
) != 0) {
178 static PyObject
* enable_callback_tracebacks(PyObject
* self
, PyObject
* args
, PyObject
* kwargs
)
180 if (!PyArg_ParseTuple(args
, "i", &_enable_callback_tracebacks
)) {
188 static void converters_init(PyObject
* dict
)
190 converters
= PyDict_New();
195 PyDict_SetItemString(dict
, "converters", converters
);
198 static PyMethodDef module_methods
[] = {
199 {"connect", (PyCFunction
)module_connect
, METH_VARARGS
|METH_KEYWORDS
, PyDoc_STR("Creates a connection.")},
200 {"complete_statement", (PyCFunction
)module_complete
, METH_VARARGS
|METH_KEYWORDS
, PyDoc_STR("Checks if a string contains a complete SQL statement. Non-standard.")},
201 #ifdef HAVE_SHARED_CACHE
202 {"enable_shared_cache", (PyCFunction
)module_enable_shared_cache
, METH_VARARGS
|METH_KEYWORDS
, PyDoc_STR("Enable or disable shared cache mode for the calling thread. Experimental/Non-standard.")},
204 {"register_adapter", (PyCFunction
)module_register_adapter
, METH_VARARGS
, PyDoc_STR("Registers an adapter with pysqlite's adapter registry. Non-standard.")},
205 {"register_converter", (PyCFunction
)module_register_converter
, METH_VARARGS
, PyDoc_STR("Registers a converter with pysqlite. Non-standard.")},
206 {"adapt", (PyCFunction
)psyco_microprotocols_adapt
, METH_VARARGS
, psyco_microprotocols_adapt_doc
},
207 {"enable_callback_tracebacks", (PyCFunction
)enable_callback_tracebacks
, METH_VARARGS
, PyDoc_STR("Enable or disable callback functions throwing errors to stderr.")},
211 struct _IntConstantPair
{
216 typedef struct _IntConstantPair IntConstantPair
;
218 static IntConstantPair _int_constants
[] = {
219 {"PARSE_DECLTYPES", PARSE_DECLTYPES
},
220 {"PARSE_COLNAMES", PARSE_COLNAMES
},
222 {"SQLITE_OK", SQLITE_OK
},
223 {"SQLITE_DENY", SQLITE_DENY
},
224 {"SQLITE_IGNORE", SQLITE_IGNORE
},
225 {"SQLITE_CREATE_INDEX", SQLITE_CREATE_INDEX
},
226 {"SQLITE_CREATE_TABLE", SQLITE_CREATE_TABLE
},
227 {"SQLITE_CREATE_TEMP_INDEX", SQLITE_CREATE_TEMP_INDEX
},
228 {"SQLITE_CREATE_TEMP_TABLE", SQLITE_CREATE_TEMP_TABLE
},
229 {"SQLITE_CREATE_TEMP_TRIGGER", SQLITE_CREATE_TEMP_TRIGGER
},
230 {"SQLITE_CREATE_TEMP_VIEW", SQLITE_CREATE_TEMP_VIEW
},
231 {"SQLITE_CREATE_TRIGGER", SQLITE_CREATE_TRIGGER
},
232 {"SQLITE_CREATE_VIEW", SQLITE_CREATE_VIEW
},
233 {"SQLITE_DELETE", SQLITE_DELETE
},
234 {"SQLITE_DROP_INDEX", SQLITE_DROP_INDEX
},
235 {"SQLITE_DROP_TABLE", SQLITE_DROP_TABLE
},
236 {"SQLITE_DROP_TEMP_INDEX", SQLITE_DROP_TEMP_INDEX
},
237 {"SQLITE_DROP_TEMP_TABLE", SQLITE_DROP_TEMP_TABLE
},
238 {"SQLITE_DROP_TEMP_TRIGGER", SQLITE_DROP_TEMP_TRIGGER
},
239 {"SQLITE_DROP_TEMP_VIEW", SQLITE_DROP_TEMP_VIEW
},
240 {"SQLITE_DROP_TRIGGER", SQLITE_DROP_TRIGGER
},
241 {"SQLITE_DROP_VIEW", SQLITE_DROP_VIEW
},
242 {"SQLITE_INSERT", SQLITE_INSERT
},
243 {"SQLITE_PRAGMA", SQLITE_PRAGMA
},
244 {"SQLITE_READ", SQLITE_READ
},
245 {"SQLITE_SELECT", SQLITE_SELECT
},
246 {"SQLITE_TRANSACTION", SQLITE_TRANSACTION
},
247 {"SQLITE_UPDATE", SQLITE_UPDATE
},
248 {"SQLITE_ATTACH", SQLITE_ATTACH
},
249 {"SQLITE_DETACH", SQLITE_DETACH
},
250 #if SQLITE_VERSION_NUMBER >= 3002001
251 {"SQLITE_ALTER_TABLE", SQLITE_ALTER_TABLE
},
252 {"SQLITE_REINDEX", SQLITE_REINDEX
},
254 #if SQLITE_VERSION_NUMBER >= 3003000
255 {"SQLITE_ANALYZE", SQLITE_ANALYZE
},
260 PyMODINIT_FUNC
init_sqlite3(void)
262 PyObject
*module
, *dict
;
266 module
= Py_InitModule("_sqlite3", module_methods
);
269 (pysqlite_row_setup_types() < 0) ||
270 (pysqlite_cursor_setup_types() < 0) ||
271 (pysqlite_connection_setup_types() < 0) ||
272 (pysqlite_cache_setup_types() < 0) ||
273 (pysqlite_statement_setup_types() < 0) ||
274 (pysqlite_prepare_protocol_setup_types() < 0)
279 Py_INCREF(&pysqlite_ConnectionType
);
280 PyModule_AddObject(module
, "Connection", (PyObject
*) &pysqlite_ConnectionType
);
281 Py_INCREF(&pysqlite_CursorType
);
282 PyModule_AddObject(module
, "Cursor", (PyObject
*) &pysqlite_CursorType
);
283 Py_INCREF(&pysqlite_CacheType
);
284 PyModule_AddObject(module
, "Statement", (PyObject
*)&pysqlite_StatementType
);
285 Py_INCREF(&pysqlite_StatementType
);
286 PyModule_AddObject(module
, "Cache", (PyObject
*) &pysqlite_CacheType
);
287 Py_INCREF(&pysqlite_PrepareProtocolType
);
288 PyModule_AddObject(module
, "PrepareProtocol", (PyObject
*) &pysqlite_PrepareProtocolType
);
289 Py_INCREF(&pysqlite_RowType
);
290 PyModule_AddObject(module
, "Row", (PyObject
*) &pysqlite_RowType
);
292 if (!(dict
= PyModule_GetDict(module
))) {
296 /*** Create DB-API Exception hierarchy */
298 if (!(pysqlite_Error
= PyErr_NewException(MODULE_NAME
".Error", PyExc_StandardError
, NULL
))) {
301 PyDict_SetItemString(dict
, "Error", pysqlite_Error
);
303 if (!(pysqlite_Warning
= PyErr_NewException(MODULE_NAME
".Warning", PyExc_StandardError
, NULL
))) {
306 PyDict_SetItemString(dict
, "Warning", pysqlite_Warning
);
308 /* Error subclasses */
310 if (!(pysqlite_InterfaceError
= PyErr_NewException(MODULE_NAME
".InterfaceError", pysqlite_Error
, NULL
))) {
313 PyDict_SetItemString(dict
, "InterfaceError", pysqlite_InterfaceError
);
315 if (!(pysqlite_DatabaseError
= PyErr_NewException(MODULE_NAME
".DatabaseError", pysqlite_Error
, NULL
))) {
318 PyDict_SetItemString(dict
, "DatabaseError", pysqlite_DatabaseError
);
320 /* pysqlite_DatabaseError subclasses */
322 if (!(pysqlite_InternalError
= PyErr_NewException(MODULE_NAME
".InternalError", pysqlite_DatabaseError
, NULL
))) {
325 PyDict_SetItemString(dict
, "InternalError", pysqlite_InternalError
);
327 if (!(pysqlite_OperationalError
= PyErr_NewException(MODULE_NAME
".OperationalError", pysqlite_DatabaseError
, NULL
))) {
330 PyDict_SetItemString(dict
, "OperationalError", pysqlite_OperationalError
);
332 if (!(pysqlite_ProgrammingError
= PyErr_NewException(MODULE_NAME
".ProgrammingError", pysqlite_DatabaseError
, NULL
))) {
335 PyDict_SetItemString(dict
, "ProgrammingError", pysqlite_ProgrammingError
);
337 if (!(pysqlite_IntegrityError
= PyErr_NewException(MODULE_NAME
".IntegrityError", pysqlite_DatabaseError
,NULL
))) {
340 PyDict_SetItemString(dict
, "IntegrityError", pysqlite_IntegrityError
);
342 if (!(pysqlite_DataError
= PyErr_NewException(MODULE_NAME
".DataError", pysqlite_DatabaseError
, NULL
))) {
345 PyDict_SetItemString(dict
, "DataError", pysqlite_DataError
);
347 if (!(pysqlite_NotSupportedError
= PyErr_NewException(MODULE_NAME
".NotSupportedError", pysqlite_DatabaseError
, NULL
))) {
350 PyDict_SetItemString(dict
, "NotSupportedError", pysqlite_NotSupportedError
);
352 /* We just need "something" unique for pysqlite_OptimizedUnicode. It does not really
353 * need to be a string subclass. Just anything that can act as a special
354 * marker for us. So I pulled PyCell_Type out of my magic hat.
356 Py_INCREF((PyObject
*)&PyCell_Type
);
357 pysqlite_OptimizedUnicode
= (PyObject
*)&PyCell_Type
;
358 PyDict_SetItemString(dict
, "OptimizedUnicode", pysqlite_OptimizedUnicode
);
360 /* Set integer constants */
361 for (i
= 0; _int_constants
[i
].constant_name
!= 0; i
++) {
362 tmp_obj
= PyInt_FromLong(_int_constants
[i
].constant_value
);
366 PyDict_SetItemString(dict
, _int_constants
[i
].constant_name
, tmp_obj
);
370 if (!(tmp_obj
= PyString_FromString(PYSQLITE_VERSION
))) {
373 PyDict_SetItemString(dict
, "version", tmp_obj
);
376 if (!(tmp_obj
= PyString_FromString(sqlite3_libversion()))) {
379 PyDict_SetItemString(dict
, "sqlite_version", tmp_obj
);
382 /* initialize microprotocols layer */
383 microprotocols_init(dict
);
385 /* initialize the default converters */
386 converters_init(dict
);
388 _enable_callback_tracebacks
= 0;
390 pysqlite_BaseTypeAdapted
= 0;
392 /* Original comment form _bsddb.c in the Python core. This is also still
393 * needed nowadays for Python 2.3/2.4.
395 * PyEval_InitThreads is called here due to a quirk in python 1.5
396 * - 2.2.1 (at least) according to Russell Williamson <merel@wt.net>:
397 * The global interepreter lock is not initialized until the first
398 * thread is created using thread.start_new_thread() or fork() is
399 * called. that would cause the ALLOW_THREADS here to segfault due
400 * to a null pointer reference if no threads or child processes
401 * have been created. This works around that and is a no-op if
402 * threads have already been initialized.
403 * (see pybsddb-users mailing list post on 2002-08-07)
405 PyEval_InitThreads();
408 if (PyErr_Occurred())
410 PyErr_SetString(PyExc_ImportError
, MODULE_NAME
": init failed");