1 /* module.c - the module itself
3 * Copyright (C) 2004-2006 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
;
45 static PyObject
* module_connect(PyObject
* self
, PyObject
* args
, PyObject
*
48 /* Python seems to have no way of extracting a single keyword-arg at
49 * C-level, so this code is redundant with the one in connection_init in
50 * connection.c and must always be copied from there ... */
52 static char *kwlist
[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", NULL
, NULL
};
55 PyObject
* isolation_level
;
56 PyObject
* factory
= NULL
;
57 int check_same_thread
= 1;
58 int cached_statements
;
63 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s|diOiOi", kwlist
,
64 &database
, &timeout
, &detect_types
, &isolation_level
, &check_same_thread
, &factory
, &cached_statements
))
69 if (factory
== NULL
) {
70 factory
= (PyObject
*)&pysqlite_ConnectionType
;
73 result
= PyObject_Call(factory
, args
, kwargs
);
78 static PyObject
* module_complete(PyObject
* self
, PyObject
* args
, PyObject
*
81 static char *kwlist
[] = {"statement", NULL
, NULL
};
86 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s", kwlist
, &statement
))
91 if (sqlite3_complete(statement
)) {
102 #ifdef HAVE_SHARED_CACHE
103 static PyObject
* module_enable_shared_cache(PyObject
* self
, PyObject
* args
, PyObject
*
106 static char *kwlist
[] = {"do_enable", NULL
, NULL
};
110 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "i", kwlist
, &do_enable
))
115 rc
= sqlite3_enable_shared_cache(do_enable
);
117 if (rc
!= SQLITE_OK
) {
118 PyErr_SetString(pysqlite_OperationalError
, "Changing the shared_cache flag failed");
125 #endif /* HAVE_SHARED_CACHE */
127 static PyObject
* module_register_adapter(PyObject
* self
, PyObject
* args
, PyObject
* kwargs
)
132 if (!PyArg_ParseTuple(args
, "OO", &type
, &caster
)) {
136 microprotocols_add(type
, (PyObject
*)&pysqlite_PrepareProtocolType
, caster
);
142 static PyObject
* module_register_converter(PyObject
* self
, PyObject
* args
, PyObject
* kwargs
)
145 PyObject
* name
= NULL
;
147 PyObject
* retval
= NULL
;
149 if (!PyArg_ParseTuple(args
, "SO", &orig_name
, &callable
)) {
153 /* convert the name to upper case */
154 name
= PyObject_CallMethod(orig_name
, "upper", "");
159 if (PyDict_SetItem(converters
, name
, callable
) != 0) {
170 static PyObject
* enable_callback_tracebacks(PyObject
* self
, PyObject
* args
, PyObject
* kwargs
)
172 if (!PyArg_ParseTuple(args
, "i", &_enable_callback_tracebacks
)) {
180 static void converters_init(PyObject
* dict
)
182 converters
= PyDict_New();
187 PyDict_SetItemString(dict
, "converters", converters
);
190 static PyMethodDef module_methods
[] = {
191 {"connect", (PyCFunction
)module_connect
, METH_VARARGS
|METH_KEYWORDS
, PyDoc_STR("Creates a connection.")},
192 {"complete_statement", (PyCFunction
)module_complete
, METH_VARARGS
|METH_KEYWORDS
, PyDoc_STR("Checks if a string contains a complete SQL statement. Non-standard.")},
193 #ifdef HAVE_SHARED_CACHE
194 {"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.")},
196 {"register_adapter", (PyCFunction
)module_register_adapter
, METH_VARARGS
, PyDoc_STR("Registers an adapter with pysqlite's adapter registry. Non-standard.")},
197 {"register_converter", (PyCFunction
)module_register_converter
, METH_VARARGS
, PyDoc_STR("Registers a converter with pysqlite. Non-standard.")},
198 {"adapt", (PyCFunction
)psyco_microprotocols_adapt
, METH_VARARGS
, psyco_microprotocols_adapt_doc
},
199 {"enable_callback_tracebacks", (PyCFunction
)enable_callback_tracebacks
, METH_VARARGS
, PyDoc_STR("Enable or disable callback functions throwing errors to stderr.")},
203 struct _IntConstantPair
{
208 typedef struct _IntConstantPair IntConstantPair
;
210 static IntConstantPair _int_constants
[] = {
211 {"PARSE_DECLTYPES", PARSE_DECLTYPES
},
212 {"PARSE_COLNAMES", PARSE_COLNAMES
},
214 {"SQLITE_OK", SQLITE_OK
},
215 {"SQLITE_DENY", SQLITE_DENY
},
216 {"SQLITE_IGNORE", SQLITE_IGNORE
},
217 {"SQLITE_CREATE_INDEX", SQLITE_CREATE_INDEX
},
218 {"SQLITE_CREATE_TABLE", SQLITE_CREATE_TABLE
},
219 {"SQLITE_CREATE_TEMP_INDEX", SQLITE_CREATE_TEMP_INDEX
},
220 {"SQLITE_CREATE_TEMP_TABLE", SQLITE_CREATE_TEMP_TABLE
},
221 {"SQLITE_CREATE_TEMP_TRIGGER", SQLITE_CREATE_TEMP_TRIGGER
},
222 {"SQLITE_CREATE_TEMP_VIEW", SQLITE_CREATE_TEMP_VIEW
},
223 {"SQLITE_CREATE_TRIGGER", SQLITE_CREATE_TRIGGER
},
224 {"SQLITE_CREATE_VIEW", SQLITE_CREATE_VIEW
},
225 {"SQLITE_DELETE", SQLITE_DELETE
},
226 {"SQLITE_DROP_INDEX", SQLITE_DROP_INDEX
},
227 {"SQLITE_DROP_TABLE", SQLITE_DROP_TABLE
},
228 {"SQLITE_DROP_TEMP_INDEX", SQLITE_DROP_TEMP_INDEX
},
229 {"SQLITE_DROP_TEMP_TABLE", SQLITE_DROP_TEMP_TABLE
},
230 {"SQLITE_DROP_TEMP_TRIGGER", SQLITE_DROP_TEMP_TRIGGER
},
231 {"SQLITE_DROP_TEMP_VIEW", SQLITE_DROP_TEMP_VIEW
},
232 {"SQLITE_DROP_TRIGGER", SQLITE_DROP_TRIGGER
},
233 {"SQLITE_DROP_VIEW", SQLITE_DROP_VIEW
},
234 {"SQLITE_INSERT", SQLITE_INSERT
},
235 {"SQLITE_PRAGMA", SQLITE_PRAGMA
},
236 {"SQLITE_READ", SQLITE_READ
},
237 {"SQLITE_SELECT", SQLITE_SELECT
},
238 {"SQLITE_TRANSACTION", SQLITE_TRANSACTION
},
239 {"SQLITE_UPDATE", SQLITE_UPDATE
},
240 {"SQLITE_ATTACH", SQLITE_ATTACH
},
241 {"SQLITE_DETACH", SQLITE_DETACH
},
242 #if SQLITE_VERSION_NUMBER >= 3002001
243 {"SQLITE_ALTER_TABLE", SQLITE_ALTER_TABLE
},
244 {"SQLITE_REINDEX", SQLITE_REINDEX
},
246 #if SQLITE_VERSION_NUMBER >= 3003000
247 {"SQLITE_ANALYZE", SQLITE_ANALYZE
},
252 PyMODINIT_FUNC
init_sqlite3(void)
254 PyObject
*module
, *dict
;
258 module
= Py_InitModule("_sqlite3", module_methods
);
261 (pysqlite_row_setup_types() < 0) ||
262 (pysqlite_cursor_setup_types() < 0) ||
263 (pysqlite_connection_setup_types() < 0) ||
264 (pysqlite_cache_setup_types() < 0) ||
265 (pysqlite_statement_setup_types() < 0) ||
266 (pysqlite_prepare_protocol_setup_types() < 0)
271 Py_INCREF(&pysqlite_ConnectionType
);
272 PyModule_AddObject(module
, "Connection", (PyObject
*) &pysqlite_ConnectionType
);
273 Py_INCREF(&pysqlite_CursorType
);
274 PyModule_AddObject(module
, "Cursor", (PyObject
*) &pysqlite_CursorType
);
275 Py_INCREF(&pysqlite_CacheType
);
276 PyModule_AddObject(module
, "Statement", (PyObject
*)&pysqlite_StatementType
);
277 Py_INCREF(&pysqlite_StatementType
);
278 PyModule_AddObject(module
, "Cache", (PyObject
*) &pysqlite_CacheType
);
279 Py_INCREF(&pysqlite_PrepareProtocolType
);
280 PyModule_AddObject(module
, "PrepareProtocol", (PyObject
*) &pysqlite_PrepareProtocolType
);
281 Py_INCREF(&pysqlite_RowType
);
282 PyModule_AddObject(module
, "Row", (PyObject
*) &pysqlite_RowType
);
284 if (!(dict
= PyModule_GetDict(module
))) {
288 /*** Create DB-API Exception hierarchy */
290 if (!(pysqlite_Error
= PyErr_NewException(MODULE_NAME
".Error", PyExc_StandardError
, NULL
))) {
293 PyDict_SetItemString(dict
, "Error", pysqlite_Error
);
295 if (!(pysqlite_Warning
= PyErr_NewException(MODULE_NAME
".Warning", PyExc_StandardError
, NULL
))) {
298 PyDict_SetItemString(dict
, "Warning", pysqlite_Warning
);
300 /* Error subclasses */
302 if (!(pysqlite_InterfaceError
= PyErr_NewException(MODULE_NAME
".InterfaceError", pysqlite_Error
, NULL
))) {
305 PyDict_SetItemString(dict
, "InterfaceError", pysqlite_InterfaceError
);
307 if (!(pysqlite_DatabaseError
= PyErr_NewException(MODULE_NAME
".DatabaseError", pysqlite_Error
, NULL
))) {
310 PyDict_SetItemString(dict
, "DatabaseError", pysqlite_DatabaseError
);
312 /* pysqlite_DatabaseError subclasses */
314 if (!(pysqlite_InternalError
= PyErr_NewException(MODULE_NAME
".InternalError", pysqlite_DatabaseError
, NULL
))) {
317 PyDict_SetItemString(dict
, "InternalError", pysqlite_InternalError
);
319 if (!(pysqlite_OperationalError
= PyErr_NewException(MODULE_NAME
".OperationalError", pysqlite_DatabaseError
, NULL
))) {
322 PyDict_SetItemString(dict
, "OperationalError", pysqlite_OperationalError
);
324 if (!(pysqlite_ProgrammingError
= PyErr_NewException(MODULE_NAME
".ProgrammingError", pysqlite_DatabaseError
, NULL
))) {
327 PyDict_SetItemString(dict
, "ProgrammingError", pysqlite_ProgrammingError
);
329 if (!(pysqlite_IntegrityError
= PyErr_NewException(MODULE_NAME
".IntegrityError", pysqlite_DatabaseError
,NULL
))) {
332 PyDict_SetItemString(dict
, "IntegrityError", pysqlite_IntegrityError
);
334 if (!(pysqlite_DataError
= PyErr_NewException(MODULE_NAME
".DataError", pysqlite_DatabaseError
, NULL
))) {
337 PyDict_SetItemString(dict
, "DataError", pysqlite_DataError
);
339 if (!(pysqlite_NotSupportedError
= PyErr_NewException(MODULE_NAME
".NotSupportedError", pysqlite_DatabaseError
, NULL
))) {
342 PyDict_SetItemString(dict
, "NotSupportedError", pysqlite_NotSupportedError
);
344 /* We just need "something" unique for pysqlite_OptimizedUnicode. It does not really
345 * need to be a string subclass. Just anything that can act as a special
346 * marker for us. So I pulled PyCell_Type out of my magic hat.
348 Py_INCREF((PyObject
*)&PyCell_Type
);
349 pysqlite_OptimizedUnicode
= (PyObject
*)&PyCell_Type
;
350 PyDict_SetItemString(dict
, "OptimizedUnicode", pysqlite_OptimizedUnicode
);
352 /* Set integer constants */
353 for (i
= 0; _int_constants
[i
].constant_name
!= 0; i
++) {
354 tmp_obj
= PyInt_FromLong(_int_constants
[i
].constant_value
);
358 PyDict_SetItemString(dict
, _int_constants
[i
].constant_name
, tmp_obj
);
362 if (!(tmp_obj
= PyString_FromString(PYSQLITE_VERSION
))) {
365 PyDict_SetItemString(dict
, "version", tmp_obj
);
368 if (!(tmp_obj
= PyString_FromString(sqlite3_libversion()))) {
371 PyDict_SetItemString(dict
, "sqlite_version", tmp_obj
);
374 /* initialize microprotocols layer */
375 microprotocols_init(dict
);
377 /* initialize the default converters */
378 converters_init(dict
);
380 _enable_callback_tracebacks
= 0;
382 /* Original comment form _bsddb.c in the Python core. This is also still
383 * needed nowadays for Python 2.3/2.4.
385 * PyEval_InitThreads is called here due to a quirk in python 1.5
386 * - 2.2.1 (at least) according to Russell Williamson <merel@wt.net>:
387 * The global interepreter lock is not initialized until the first
388 * thread is created using thread.start_new_thread() or fork() is
389 * called. that would cause the ALLOW_THREADS here to segfault due
390 * to a null pointer reference if no threads or child processes
391 * have been created. This works around that and is a no-op if
392 * threads have already been initialized.
393 * (see pybsddb-users mailing list post on 2002-08-07)
395 PyEval_InitThreads();
398 if (PyErr_Occurred())
400 PyErr_SetString(PyExc_ImportError
, MODULE_NAME
": init failed");