Gerhard Häring | e7ea745 | 2008-03-29 00:45:29 +0000 | [diff] [blame] | 1 | /* module.c - the module itself |
| 2 | * |
Florent Xicluna | c934f32 | 2010-09-03 23:47:32 +0000 | [diff] [blame] | 3 | * Copyright (C) 2004-2010 Gerhard Häring <gh@ghaering.de> |
Gerhard Häring | e7ea745 | 2008-03-29 00:45:29 +0000 | [diff] [blame] | 4 | * |
| 5 | * This file is part of pysqlite. |
| 6 | * |
| 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. |
| 10 | * |
| 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: |
| 14 | * |
| 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. |
| 22 | */ |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 23 | |
| 24 | #include "connection.h" |
| 25 | #include "statement.h" |
| 26 | #include "cursor.h" |
| 27 | #include "cache.h" |
| 28 | #include "prepare_protocol.h" |
| 29 | #include "microprotocols.h" |
| 30 | #include "row.h" |
| 31 | |
| 32 | #if SQLITE_VERSION_NUMBER >= 3003003 |
| 33 | #define HAVE_SHARED_CACHE |
| 34 | #endif |
| 35 | |
| 36 | /* static objects at module-level */ |
| 37 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 38 | PyObject* pysqlite_Error, *pysqlite_Warning, *pysqlite_InterfaceError, *pysqlite_DatabaseError, |
| 39 | *pysqlite_InternalError, *pysqlite_OperationalError, *pysqlite_ProgrammingError, |
Petri Lehtinen | bc35beb | 2012-02-09 21:09:03 +0200 | [diff] [blame] | 40 | *pysqlite_IntegrityError, *pysqlite_DataError, *pysqlite_NotSupportedError; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 41 | |
| 42 | PyObject* converters; |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 43 | int _enable_callback_tracebacks; |
Gerhard Häring | e7ea745 | 2008-03-29 00:45:29 +0000 | [diff] [blame] | 44 | int pysqlite_BaseTypeAdapted; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 45 | |
| 46 | static PyObject* module_connect(PyObject* self, PyObject* args, PyObject* |
| 47 | kwargs) |
| 48 | { |
| 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 ... */ |
| 52 | |
Antoine Pitrou | 902fc8b | 2013-02-10 00:02:44 +0100 | [diff] [blame] | 53 | static char *kwlist[] = { |
| 54 | "database", "timeout", "detect_types", "isolation_level", |
| 55 | "check_same_thread", "factory", "cached_statements", "uri", |
| 56 | NULL |
| 57 | }; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 58 | char* database; |
| 59 | int detect_types = 0; |
| 60 | PyObject* isolation_level; |
| 61 | PyObject* factory = NULL; |
| 62 | int check_same_thread = 1; |
| 63 | int cached_statements; |
Antoine Pitrou | 902fc8b | 2013-02-10 00:02:44 +0100 | [diff] [blame] | 64 | int uri = 0; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 65 | double timeout = 5.0; |
| 66 | |
| 67 | PyObject* result; |
| 68 | |
Antoine Pitrou | 902fc8b | 2013-02-10 00:02:44 +0100 | [diff] [blame] | 69 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|diOiOip", kwlist, |
| 70 | &database, &timeout, &detect_types, |
| 71 | &isolation_level, &check_same_thread, |
| 72 | &factory, &cached_statements, &uri)) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 73 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 74 | return NULL; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | if (factory == NULL) { |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 78 | factory = (PyObject*)&pysqlite_ConnectionType; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 79 | } |
| 80 | |
| 81 | result = PyObject_Call(factory, args, kwargs); |
| 82 | |
| 83 | return result; |
| 84 | } |
| 85 | |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 86 | PyDoc_STRVAR(module_connect_doc, |
Antoine Pitrou | 902fc8b | 2013-02-10 00:02:44 +0100 | [diff] [blame] | 87 | "connect(database[, timeout, detect_types, isolation_level,\n\ |
| 88 | check_same_thread, factory, cached_statements, uri])\n\ |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 89 | \n\ |
| 90 | Opens a connection to the SQLite database file *database*. You can use\n\ |
| 91 | \":memory:\" to open a database connection to a database that resides in\n\ |
| 92 | RAM instead of on disk."); |
| 93 | |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 94 | static PyObject* module_complete(PyObject* self, PyObject* args, PyObject* |
| 95 | kwargs) |
| 96 | { |
| 97 | static char *kwlist[] = {"statement", NULL, NULL}; |
| 98 | char* statement; |
| 99 | |
| 100 | PyObject* result; |
| 101 | |
| 102 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &statement)) |
| 103 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 104 | return NULL; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | if (sqlite3_complete(statement)) { |
| 108 | result = Py_True; |
| 109 | } else { |
| 110 | result = Py_False; |
| 111 | } |
| 112 | |
| 113 | Py_INCREF(result); |
| 114 | |
| 115 | return result; |
| 116 | } |
| 117 | |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 118 | PyDoc_STRVAR(module_complete_doc, |
| 119 | "complete_statement(sql)\n\ |
| 120 | \n\ |
| 121 | Checks if a string contains a complete SQL statement. Non-standard."); |
| 122 | |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 123 | #ifdef HAVE_SHARED_CACHE |
| 124 | static PyObject* module_enable_shared_cache(PyObject* self, PyObject* args, PyObject* |
| 125 | kwargs) |
| 126 | { |
| 127 | static char *kwlist[] = {"do_enable", NULL, NULL}; |
| 128 | int do_enable; |
| 129 | int rc; |
| 130 | |
| 131 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", kwlist, &do_enable)) |
| 132 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 133 | return NULL; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | rc = sqlite3_enable_shared_cache(do_enable); |
| 137 | |
| 138 | if (rc != SQLITE_OK) { |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 139 | PyErr_SetString(pysqlite_OperationalError, "Changing the shared_cache flag failed"); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 140 | return NULL; |
| 141 | } else { |
| 142 | Py_INCREF(Py_None); |
| 143 | return Py_None; |
| 144 | } |
| 145 | } |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 146 | |
| 147 | PyDoc_STRVAR(module_enable_shared_cache_doc, |
| 148 | "enable_shared_cache(do_enable)\n\ |
| 149 | \n\ |
| 150 | Enable or disable shared cache mode for the calling thread.\n\ |
| 151 | Experimental/Non-standard."); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 152 | #endif /* HAVE_SHARED_CACHE */ |
| 153 | |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 154 | static PyObject* module_register_adapter(PyObject* self, PyObject* args) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 155 | { |
| 156 | PyTypeObject* type; |
| 157 | PyObject* caster; |
Georg Brandl | 3dbca81 | 2008-07-23 16:10:53 +0000 | [diff] [blame] | 158 | int rc; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 159 | |
| 160 | if (!PyArg_ParseTuple(args, "OO", &type, &caster)) { |
| 161 | return NULL; |
| 162 | } |
| 163 | |
Gerhard Häring | e7ea745 | 2008-03-29 00:45:29 +0000 | [diff] [blame] | 164 | /* a basic type is adapted; there's a performance optimization if that's not the case |
| 165 | * (99 % of all usages) */ |
| 166 | if (type == &PyLong_Type || type == &PyFloat_Type |
Christian Heimes | 9c4756e | 2008-05-26 13:22:05 +0000 | [diff] [blame] | 167 | || type == &PyUnicode_Type || type == &PyByteArray_Type) { |
Gerhard Häring | e7ea745 | 2008-03-29 00:45:29 +0000 | [diff] [blame] | 168 | pysqlite_BaseTypeAdapted = 1; |
| 169 | } |
| 170 | |
Benjamin Peterson | d7b0328 | 2008-09-13 15:58:53 +0000 | [diff] [blame] | 171 | rc = pysqlite_microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster); |
Georg Brandl | 3dbca81 | 2008-07-23 16:10:53 +0000 | [diff] [blame] | 172 | if (rc == -1) |
| 173 | return NULL; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 174 | |
| 175 | Py_INCREF(Py_None); |
| 176 | return Py_None; |
| 177 | } |
| 178 | |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 179 | PyDoc_STRVAR(module_register_adapter_doc, |
| 180 | "register_adapter(type, callable)\n\ |
| 181 | \n\ |
| 182 | Registers an adapter with pysqlite's adapter registry. Non-standard."); |
| 183 | |
| 184 | static PyObject* module_register_converter(PyObject* self, PyObject* args) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 185 | { |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 186 | PyObject* orig_name; |
| 187 | PyObject* name = NULL; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 188 | PyObject* callable; |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 189 | PyObject* retval = NULL; |
Martin v. Löwis | bd928fe | 2011-10-14 10:20:37 +0200 | [diff] [blame] | 190 | _Py_IDENTIFIER(upper); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 191 | |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 192 | if (!PyArg_ParseTuple(args, "UO", &orig_name, &callable)) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 193 | return NULL; |
| 194 | } |
| 195 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 196 | /* convert the name to upper case */ |
Martin v. Löwis | afe55bb | 2011-10-09 10:38:36 +0200 | [diff] [blame] | 197 | name = _PyObject_CallMethodId(orig_name, &PyId_upper, ""); |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 198 | if (!name) { |
| 199 | goto error; |
| 200 | } |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 201 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 202 | if (PyDict_SetItem(converters, name, callable) != 0) { |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 203 | goto error; |
| 204 | } |
| 205 | |
| 206 | Py_INCREF(Py_None); |
| 207 | retval = Py_None; |
| 208 | error: |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 209 | Py_XDECREF(name); |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 210 | return retval; |
| 211 | } |
| 212 | |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 213 | PyDoc_STRVAR(module_register_converter_doc, |
| 214 | "register_converter(typename, callable)\n\ |
| 215 | \n\ |
| 216 | Registers a converter with pysqlite. Non-standard."); |
| 217 | |
| 218 | static PyObject* enable_callback_tracebacks(PyObject* self, PyObject* args) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 219 | { |
| 220 | if (!PyArg_ParseTuple(args, "i", &_enable_callback_tracebacks)) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 221 | return NULL; |
| 222 | } |
| 223 | |
| 224 | Py_INCREF(Py_None); |
| 225 | return Py_None; |
| 226 | } |
| 227 | |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 228 | PyDoc_STRVAR(enable_callback_tracebacks_doc, |
| 229 | "enable_callback_tracebacks(flag)\n\ |
| 230 | \n\ |
| 231 | Enable or disable callback functions throwing errors to stderr."); |
| 232 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 233 | static void converters_init(PyObject* dict) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 234 | { |
| 235 | converters = PyDict_New(); |
| 236 | if (!converters) { |
| 237 | return; |
| 238 | } |
| 239 | |
| 240 | PyDict_SetItemString(dict, "converters", converters); |
| 241 | } |
| 242 | |
| 243 | static PyMethodDef module_methods[] = { |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 244 | {"connect", (PyCFunction)module_connect, |
| 245 | METH_VARARGS | METH_KEYWORDS, module_connect_doc}, |
| 246 | {"complete_statement", (PyCFunction)module_complete, |
| 247 | METH_VARARGS | METH_KEYWORDS, module_complete_doc}, |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 248 | #ifdef HAVE_SHARED_CACHE |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 249 | {"enable_shared_cache", (PyCFunction)module_enable_shared_cache, |
| 250 | METH_VARARGS | METH_KEYWORDS, module_enable_shared_cache_doc}, |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 251 | #endif |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 252 | {"register_adapter", (PyCFunction)module_register_adapter, |
| 253 | METH_VARARGS, module_register_adapter_doc}, |
| 254 | {"register_converter", (PyCFunction)module_register_converter, |
| 255 | METH_VARARGS, module_register_converter_doc}, |
Benjamin Peterson | d7b0328 | 2008-09-13 15:58:53 +0000 | [diff] [blame] | 256 | {"adapt", (PyCFunction)pysqlite_adapt, METH_VARARGS, |
| 257 | pysqlite_adapt_doc}, |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 258 | {"enable_callback_tracebacks", (PyCFunction)enable_callback_tracebacks, |
| 259 | METH_VARARGS, enable_callback_tracebacks_doc}, |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 260 | {NULL, NULL} |
| 261 | }; |
| 262 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 263 | struct _IntConstantPair { |
| 264 | char* constant_name; |
| 265 | int constant_value; |
| 266 | }; |
| 267 | |
| 268 | typedef struct _IntConstantPair IntConstantPair; |
| 269 | |
| 270 | static IntConstantPair _int_constants[] = { |
| 271 | {"PARSE_DECLTYPES", PARSE_DECLTYPES}, |
| 272 | {"PARSE_COLNAMES", PARSE_COLNAMES}, |
| 273 | |
| 274 | {"SQLITE_OK", SQLITE_OK}, |
| 275 | {"SQLITE_DENY", SQLITE_DENY}, |
| 276 | {"SQLITE_IGNORE", SQLITE_IGNORE}, |
| 277 | {"SQLITE_CREATE_INDEX", SQLITE_CREATE_INDEX}, |
| 278 | {"SQLITE_CREATE_TABLE", SQLITE_CREATE_TABLE}, |
| 279 | {"SQLITE_CREATE_TEMP_INDEX", SQLITE_CREATE_TEMP_INDEX}, |
| 280 | {"SQLITE_CREATE_TEMP_TABLE", SQLITE_CREATE_TEMP_TABLE}, |
| 281 | {"SQLITE_CREATE_TEMP_TRIGGER", SQLITE_CREATE_TEMP_TRIGGER}, |
| 282 | {"SQLITE_CREATE_TEMP_VIEW", SQLITE_CREATE_TEMP_VIEW}, |
| 283 | {"SQLITE_CREATE_TRIGGER", SQLITE_CREATE_TRIGGER}, |
| 284 | {"SQLITE_CREATE_VIEW", SQLITE_CREATE_VIEW}, |
| 285 | {"SQLITE_DELETE", SQLITE_DELETE}, |
| 286 | {"SQLITE_DROP_INDEX", SQLITE_DROP_INDEX}, |
| 287 | {"SQLITE_DROP_TABLE", SQLITE_DROP_TABLE}, |
| 288 | {"SQLITE_DROP_TEMP_INDEX", SQLITE_DROP_TEMP_INDEX}, |
| 289 | {"SQLITE_DROP_TEMP_TABLE", SQLITE_DROP_TEMP_TABLE}, |
| 290 | {"SQLITE_DROP_TEMP_TRIGGER", SQLITE_DROP_TEMP_TRIGGER}, |
| 291 | {"SQLITE_DROP_TEMP_VIEW", SQLITE_DROP_TEMP_VIEW}, |
| 292 | {"SQLITE_DROP_TRIGGER", SQLITE_DROP_TRIGGER}, |
| 293 | {"SQLITE_DROP_VIEW", SQLITE_DROP_VIEW}, |
| 294 | {"SQLITE_INSERT", SQLITE_INSERT}, |
| 295 | {"SQLITE_PRAGMA", SQLITE_PRAGMA}, |
| 296 | {"SQLITE_READ", SQLITE_READ}, |
| 297 | {"SQLITE_SELECT", SQLITE_SELECT}, |
| 298 | {"SQLITE_TRANSACTION", SQLITE_TRANSACTION}, |
| 299 | {"SQLITE_UPDATE", SQLITE_UPDATE}, |
| 300 | {"SQLITE_ATTACH", SQLITE_ATTACH}, |
| 301 | {"SQLITE_DETACH", SQLITE_DETACH}, |
| 302 | #if SQLITE_VERSION_NUMBER >= 3002001 |
| 303 | {"SQLITE_ALTER_TABLE", SQLITE_ALTER_TABLE}, |
| 304 | {"SQLITE_REINDEX", SQLITE_REINDEX}, |
| 305 | #endif |
| 306 | #if SQLITE_VERSION_NUMBER >= 3003000 |
| 307 | {"SQLITE_ANALYZE", SQLITE_ANALYZE}, |
| 308 | #endif |
| 309 | {(char*)NULL, 0} |
| 310 | }; |
| 311 | |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 312 | |
| 313 | static struct PyModuleDef _sqlite3module = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 314 | PyModuleDef_HEAD_INIT, |
| 315 | "_sqlite3", |
| 316 | NULL, |
| 317 | -1, |
| 318 | module_methods, |
| 319 | NULL, |
| 320 | NULL, |
| 321 | NULL, |
| 322 | NULL |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 323 | }; |
| 324 | |
| 325 | PyMODINIT_FUNC PyInit__sqlite3(void) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 326 | { |
| 327 | PyObject *module, *dict; |
| 328 | PyObject *tmp_obj; |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 329 | int i; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 330 | |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 331 | module = PyModule_Create(&_sqlite3module); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 332 | |
| 333 | if (!module || |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 334 | (pysqlite_row_setup_types() < 0) || |
| 335 | (pysqlite_cursor_setup_types() < 0) || |
| 336 | (pysqlite_connection_setup_types() < 0) || |
| 337 | (pysqlite_cache_setup_types() < 0) || |
| 338 | (pysqlite_statement_setup_types() < 0) || |
| 339 | (pysqlite_prepare_protocol_setup_types() < 0) |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 340 | ) { |
Brett Cannon | e144507 | 2011-02-04 20:24:02 +0000 | [diff] [blame] | 341 | Py_XDECREF(module); |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 342 | return NULL; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 343 | } |
| 344 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 345 | Py_INCREF(&pysqlite_ConnectionType); |
| 346 | PyModule_AddObject(module, "Connection", (PyObject*) &pysqlite_ConnectionType); |
| 347 | Py_INCREF(&pysqlite_CursorType); |
| 348 | PyModule_AddObject(module, "Cursor", (PyObject*) &pysqlite_CursorType); |
| 349 | Py_INCREF(&pysqlite_CacheType); |
| 350 | PyModule_AddObject(module, "Statement", (PyObject*)&pysqlite_StatementType); |
| 351 | Py_INCREF(&pysqlite_StatementType); |
| 352 | PyModule_AddObject(module, "Cache", (PyObject*) &pysqlite_CacheType); |
| 353 | Py_INCREF(&pysqlite_PrepareProtocolType); |
| 354 | PyModule_AddObject(module, "PrepareProtocol", (PyObject*) &pysqlite_PrepareProtocolType); |
| 355 | Py_INCREF(&pysqlite_RowType); |
| 356 | PyModule_AddObject(module, "Row", (PyObject*) &pysqlite_RowType); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 357 | |
| 358 | if (!(dict = PyModule_GetDict(module))) { |
| 359 | goto error; |
| 360 | } |
| 361 | |
| 362 | /*** Create DB-API Exception hierarchy */ |
| 363 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 364 | if (!(pysqlite_Error = PyErr_NewException(MODULE_NAME ".Error", PyExc_Exception, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 365 | goto error; |
| 366 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 367 | PyDict_SetItemString(dict, "Error", pysqlite_Error); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 368 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 369 | if (!(pysqlite_Warning = PyErr_NewException(MODULE_NAME ".Warning", PyExc_Exception, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 370 | goto error; |
| 371 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 372 | PyDict_SetItemString(dict, "Warning", pysqlite_Warning); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 373 | |
| 374 | /* Error subclasses */ |
| 375 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 376 | if (!(pysqlite_InterfaceError = PyErr_NewException(MODULE_NAME ".InterfaceError", pysqlite_Error, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 377 | goto error; |
| 378 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 379 | PyDict_SetItemString(dict, "InterfaceError", pysqlite_InterfaceError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 380 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 381 | if (!(pysqlite_DatabaseError = PyErr_NewException(MODULE_NAME ".DatabaseError", pysqlite_Error, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 382 | goto error; |
| 383 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 384 | PyDict_SetItemString(dict, "DatabaseError", pysqlite_DatabaseError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 385 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 386 | /* pysqlite_DatabaseError subclasses */ |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 387 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 388 | if (!(pysqlite_InternalError = PyErr_NewException(MODULE_NAME ".InternalError", pysqlite_DatabaseError, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 389 | goto error; |
| 390 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 391 | PyDict_SetItemString(dict, "InternalError", pysqlite_InternalError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 392 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 393 | if (!(pysqlite_OperationalError = PyErr_NewException(MODULE_NAME ".OperationalError", pysqlite_DatabaseError, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 394 | goto error; |
| 395 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 396 | PyDict_SetItemString(dict, "OperationalError", pysqlite_OperationalError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 397 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 398 | if (!(pysqlite_ProgrammingError = PyErr_NewException(MODULE_NAME ".ProgrammingError", pysqlite_DatabaseError, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 399 | goto error; |
| 400 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 401 | PyDict_SetItemString(dict, "ProgrammingError", pysqlite_ProgrammingError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 402 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 403 | if (!(pysqlite_IntegrityError = PyErr_NewException(MODULE_NAME ".IntegrityError", pysqlite_DatabaseError,NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 404 | goto error; |
| 405 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 406 | PyDict_SetItemString(dict, "IntegrityError", pysqlite_IntegrityError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 407 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 408 | if (!(pysqlite_DataError = PyErr_NewException(MODULE_NAME ".DataError", pysqlite_DatabaseError, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 409 | goto error; |
| 410 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 411 | PyDict_SetItemString(dict, "DataError", pysqlite_DataError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 412 | |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 413 | if (!(pysqlite_NotSupportedError = PyErr_NewException(MODULE_NAME ".NotSupportedError", pysqlite_DatabaseError, NULL))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 414 | goto error; |
| 415 | } |
Thomas Wouters | fc7bb8c | 2007-01-15 15:49:28 +0000 | [diff] [blame] | 416 | PyDict_SetItemString(dict, "NotSupportedError", pysqlite_NotSupportedError); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 417 | |
Petri Lehtinen | bc35beb | 2012-02-09 21:09:03 +0200 | [diff] [blame] | 418 | /* In Python 2.x, setting Connection.text_factory to |
| 419 | OptimizedUnicode caused Unicode objects to be returned for |
| 420 | non-ASCII data and bytestrings to be returned for ASCII data. |
| 421 | Now OptimizedUnicode is an alias for str, so it has no |
| 422 | effect. */ |
| 423 | Py_INCREF((PyObject*)&PyUnicode_Type); |
| 424 | PyDict_SetItemString(dict, "OptimizedUnicode", (PyObject*)&PyUnicode_Type); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 425 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 426 | /* Set integer constants */ |
| 427 | for (i = 0; _int_constants[i].constant_name != 0; i++) { |
Christian Heimes | 217cfd1 | 2007-12-02 14:31:20 +0000 | [diff] [blame] | 428 | tmp_obj = PyLong_FromLong(_int_constants[i].constant_value); |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 429 | if (!tmp_obj) { |
| 430 | goto error; |
| 431 | } |
| 432 | PyDict_SetItemString(dict, _int_constants[i].constant_name, tmp_obj); |
| 433 | Py_DECREF(tmp_obj); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 434 | } |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 435 | |
Neal Norwitz | efee9f5 | 2007-10-27 02:50:52 +0000 | [diff] [blame] | 436 | if (!(tmp_obj = PyUnicode_FromString(PYSQLITE_VERSION))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 437 | goto error; |
| 438 | } |
| 439 | PyDict_SetItemString(dict, "version", tmp_obj); |
Thomas Wouters | 4d70c3d | 2006-06-08 14:42:34 +0000 | [diff] [blame] | 440 | Py_DECREF(tmp_obj); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 441 | |
Neal Norwitz | efee9f5 | 2007-10-27 02:50:52 +0000 | [diff] [blame] | 442 | if (!(tmp_obj = PyUnicode_FromString(sqlite3_libversion()))) { |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 443 | goto error; |
| 444 | } |
| 445 | PyDict_SetItemString(dict, "sqlite_version", tmp_obj); |
Thomas Wouters | 4d70c3d | 2006-06-08 14:42:34 +0000 | [diff] [blame] | 446 | Py_DECREF(tmp_obj); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 447 | |
| 448 | /* initialize microprotocols layer */ |
Benjamin Peterson | d7b0328 | 2008-09-13 15:58:53 +0000 | [diff] [blame] | 449 | pysqlite_microprotocols_init(dict); |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 450 | |
| 451 | /* initialize the default converters */ |
| 452 | converters_init(dict); |
| 453 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 454 | _enable_callback_tracebacks = 0; |
| 455 | |
Gerhard Häring | e7ea745 | 2008-03-29 00:45:29 +0000 | [diff] [blame] | 456 | pysqlite_BaseTypeAdapted = 0; |
| 457 | |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 458 | /* Original comment from _bsddb.c in the Python core. This is also still |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 459 | * needed nowadays for Python 2.3/2.4. |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 460 | * |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 461 | * PyEval_InitThreads is called here due to a quirk in python 1.5 |
| 462 | * - 2.2.1 (at least) according to Russell Williamson <merel@wt.net>: |
Benjamin Peterson | dcf97b9 | 2008-07-02 17:30:14 +0000 | [diff] [blame] | 463 | * The global interpreter lock is not initialized until the first |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 464 | * thread is created using thread.start_new_thread() or fork() is |
| 465 | * called. that would cause the ALLOW_THREADS here to segfault due |
| 466 | * to a null pointer reference if no threads or child processes |
| 467 | * have been created. This works around that and is a no-op if |
| 468 | * threads have already been initialized. |
| 469 | * (see pybsddb-users mailing list post on 2002-08-07) |
| 470 | */ |
Georg Brandl | dfd7344 | 2009-04-05 11:47:34 +0000 | [diff] [blame] | 471 | #ifdef WITH_THREAD |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 472 | PyEval_InitThreads(); |
Georg Brandl | dfd7344 | 2009-04-05 11:47:34 +0000 | [diff] [blame] | 473 | #endif |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 474 | |
| 475 | error: |
| 476 | if (PyErr_Occurred()) |
| 477 | { |
| 478 | PyErr_SetString(PyExc_ImportError, MODULE_NAME ": init failed"); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 479 | Py_DECREF(module); |
| 480 | module = NULL; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 481 | } |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 482 | return module; |
Thomas Wouters | 49fd7fa | 2006-04-21 10:40:58 +0000 | [diff] [blame] | 483 | } |