diff options
Diffstat (limited to 'Modules')
| -rw-r--r-- | Modules/_sqlite/cache.c | 58 | ||||
| -rw-r--r-- | Modules/_sqlite/cache.h | 30 | ||||
| -rw-r--r-- | Modules/_sqlite/connection.c | 260 | ||||
| -rw-r--r-- | Modules/_sqlite/connection.h | 31 | ||||
| -rw-r--r-- | Modules/_sqlite/cursor.c | 220 | ||||
| -rw-r--r-- | Modules/_sqlite/cursor.h | 34 | ||||
| -rw-r--r-- | Modules/_sqlite/microprotocols.c | 10 | ||||
| -rw-r--r-- | Modules/_sqlite/microprotocols.h | 2 | ||||
| -rw-r--r-- | Modules/_sqlite/module.c | 119 | ||||
| -rw-r--r-- | Modules/_sqlite/module.h | 28 | ||||
| -rw-r--r-- | Modules/_sqlite/prepare_protocol.c | 20 | ||||
| -rw-r--r-- | Modules/_sqlite/prepare_protocol.h | 10 | ||||
| -rw-r--r-- | Modules/_sqlite/row.c | 75 | ||||
| -rw-r--r-- | Modules/_sqlite/row.h | 6 | ||||
| -rw-r--r-- | Modules/_sqlite/statement.c | 54 | ||||
| -rw-r--r-- | Modules/_sqlite/statement.h | 22 | ||||
| -rw-r--r-- | Modules/_sqlite/util.c | 19 | ||||
| -rw-r--r-- | Modules/_sqlite/util.h | 4 |
18 files changed, 518 insertions, 484 deletions
diff --git a/Modules/_sqlite/cache.c b/Modules/_sqlite/cache.c index 6962695..18a4066 100644 --- a/Modules/_sqlite/cache.c +++ b/Modules/_sqlite/cache.c @@ -25,11 +25,11 @@ #include <limits.h> /* only used internally */ -Node* new_node(PyObject* key, PyObject* data) +pysqlite_Node* pysqlite_new_node(PyObject* key, PyObject* data) { - Node* node; + pysqlite_Node* node; - node = (Node*) (NodeType.tp_alloc(&NodeType, 0)); + node = (pysqlite_Node*) (pysqlite_NodeType.tp_alloc(&pysqlite_NodeType, 0)); if (!node) { return NULL; } @@ -46,7 +46,7 @@ Node* new_node(PyObject* key, PyObject* data) return node; } -void node_dealloc(Node* self) +void pysqlite_node_dealloc(pysqlite_Node* self) { Py_DECREF(self->key); Py_DECREF(self->data); @@ -54,7 +54,7 @@ void node_dealloc(Node* self) self->ob_type->tp_free((PyObject*)self); } -int cache_init(Cache* self, PyObject* args, PyObject* kwargs) +int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs) { PyObject* factory; int size = 10; @@ -86,10 +86,10 @@ int cache_init(Cache* self, PyObject* args, PyObject* kwargs) return 0; } -void cache_dealloc(Cache* self) +void pysqlite_cache_dealloc(pysqlite_Cache* self) { - Node* node; - Node* delete_node; + pysqlite_Node* node; + pysqlite_Node* delete_node; if (!self->factory) { /* constructor failed, just get out of here */ @@ -112,14 +112,14 @@ void cache_dealloc(Cache* self) self->ob_type->tp_free((PyObject*)self); } -PyObject* cache_get(Cache* self, PyObject* args) +PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* args) { PyObject* key = args; - Node* node; - Node* ptr; + pysqlite_Node* node; + pysqlite_Node* ptr; PyObject* data; - node = (Node*)PyDict_GetItem(self->mapping, key); + node = (pysqlite_Node*)PyDict_GetItem(self->mapping, key); if (node) { /* an entry for this key already exists in the cache */ @@ -186,7 +186,7 @@ PyObject* cache_get(Cache* self, PyObject* args) return NULL; } - node = new_node(key, data); + node = pysqlite_new_node(key, data); if (!node) { return NULL; } @@ -211,9 +211,9 @@ PyObject* cache_get(Cache* self, PyObject* args) return node->data; } -PyObject* cache_display(Cache* self, PyObject* args) +PyObject* pysqlite_cache_display(pysqlite_Cache* self, PyObject* args) { - Node* ptr; + pysqlite_Node* ptr; PyObject* prevkey; PyObject* nextkey; PyObject* fmt_args; @@ -265,20 +265,20 @@ PyObject* cache_display(Cache* self, PyObject* args) } static PyMethodDef cache_methods[] = { - {"get", (PyCFunction)cache_get, METH_O, + {"get", (PyCFunction)pysqlite_cache_get, METH_O, PyDoc_STR("Gets an entry from the cache or calls the factory function to produce one.")}, - {"display", (PyCFunction)cache_display, METH_NOARGS, + {"display", (PyCFunction)pysqlite_cache_display, METH_NOARGS, PyDoc_STR("For debugging only.")}, {NULL, NULL} }; -PyTypeObject NodeType = { +PyTypeObject pysqlite_NodeType = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ MODULE_NAME "Node", /* tp_name */ - sizeof(Node), /* tp_basicsize */ + sizeof(pysqlite_Node), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)node_dealloc, /* tp_dealloc */ + (destructor)pysqlite_node_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ @@ -315,13 +315,13 @@ PyTypeObject NodeType = { 0 /* tp_free */ }; -PyTypeObject CacheType = { +PyTypeObject pysqlite_CacheType = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ MODULE_NAME ".Cache", /* tp_name */ - sizeof(Cache), /* tp_basicsize */ + sizeof(pysqlite_Cache), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)cache_dealloc, /* tp_dealloc */ + (destructor)pysqlite_cache_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ @@ -352,24 +352,24 @@ PyTypeObject CacheType = { 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)cache_init, /* tp_init */ + (initproc)pysqlite_cache_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0 /* tp_free */ }; -extern int cache_setup_types(void) +extern int pysqlite_cache_setup_types(void) { int rc; - NodeType.tp_new = PyType_GenericNew; - CacheType.tp_new = PyType_GenericNew; + pysqlite_NodeType.tp_new = PyType_GenericNew; + pysqlite_CacheType.tp_new = PyType_GenericNew; - rc = PyType_Ready(&NodeType); + rc = PyType_Ready(&pysqlite_NodeType); if (rc < 0) { return rc; } - rc = PyType_Ready(&CacheType); + rc = PyType_Ready(&pysqlite_CacheType); return rc; } diff --git a/Modules/_sqlite/cache.h b/Modules/_sqlite/cache.h index 1f13907..158bf5a 100644 --- a/Modules/_sqlite/cache.h +++ b/Modules/_sqlite/cache.h @@ -29,15 +29,15 @@ * dictionary. The list items are of type 'Node' and the dictionary has the * nodes as values. */ -typedef struct _Node +typedef struct _pysqlite_Node { PyObject_HEAD PyObject* key; PyObject* data; long count; - struct _Node* prev; - struct _Node* next; -} Node; + struct _pysqlite_Node* prev; + struct _pysqlite_Node* next; +} pysqlite_Node; typedef struct { @@ -50,24 +50,24 @@ typedef struct /* the factory callable */ PyObject* factory; - Node* first; - Node* last; + pysqlite_Node* first; + pysqlite_Node* last; /* if set, decrement the factory function when the Cache is deallocated. * this is almost always desirable, but not in the pysqlite context */ int decref_factory; -} Cache; +} pysqlite_Cache; -extern PyTypeObject NodeType; -extern PyTypeObject CacheType; +extern PyTypeObject pysqlite_NodeType; +extern PyTypeObject pysqlite_CacheType; -int node_init(Node* self, PyObject* args, PyObject* kwargs); -void node_dealloc(Node* self); +int pysqlite_node_init(pysqlite_Node* self, PyObject* args, PyObject* kwargs); +void pysqlite_node_dealloc(pysqlite_Node* self); -int cache_init(Cache* self, PyObject* args, PyObject* kwargs); -void cache_dealloc(Cache* self); -PyObject* cache_get(Cache* self, PyObject* args); +int pysqlite_cache_init(pysqlite_Cache* self, PyObject* args, PyObject* kwargs); +void pysqlite_cache_dealloc(pysqlite_Cache* self); +PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* args); -int cache_setup_types(void); +int pysqlite_cache_setup_types(void); #endif diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c index 703af15..924d582 100644 --- a/Modules/_sqlite/connection.c +++ b/Modules/_sqlite/connection.c @@ -32,7 +32,7 @@ #include "pythread.h" -static int connection_set_isolation_level(Connection* self, PyObject* isolation_level); +static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level); void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len) @@ -43,11 +43,11 @@ void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len) #if SQLITE_VERSION_NUMBER >= 3003003 sqlite3_result_error(ctx, errmsg, len); #else - PyErr_SetString(OperationalError, errmsg); + PyErr_SetString(pysqlite_OperationalError, errmsg); #endif } -int connection_init(Connection* self, PyObject* args, PyObject* kwargs) +int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { static char *kwlist[] = {"database", "timeout", "detect_types", "isolation_level", "check_same_thread", "factory", "cached_statements", NULL, NULL}; @@ -82,7 +82,7 @@ int connection_init(Connection* self, PyObject* args, PyObject* kwargs) Py_END_ALLOW_THREADS if (rc != SQLITE_OK) { - _seterror(self->db); + _pysqlite_seterror(self->db); return -1; } @@ -95,10 +95,10 @@ int connection_init(Connection* self, PyObject* args, PyObject* kwargs) Py_INCREF(isolation_level); } self->isolation_level = NULL; - connection_set_isolation_level(self, isolation_level); + pysqlite_connection_set_isolation_level(self, isolation_level); Py_DECREF(isolation_level); - self->statement_cache = (Cache*)PyObject_CallFunction((PyObject*)&CacheType, "Oi", self, cached_statements); + self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements); if (PyErr_Occurred()) { return -1; } @@ -135,41 +135,41 @@ int connection_init(Connection* self, PyObject* args, PyObject* kwargs) return -1; } - self->Warning = Warning; - self->Error = Error; - self->InterfaceError = InterfaceError; - self->DatabaseError = DatabaseError; - self->DataError = DataError; - self->OperationalError = OperationalError; - self->IntegrityError = IntegrityError; - self->InternalError = InternalError; - self->ProgrammingError = ProgrammingError; - self->NotSupportedError = NotSupportedError; + self->Warning = pysqlite_Warning; + self->Error = pysqlite_Error; + self->InterfaceError = pysqlite_InterfaceError; + self->DatabaseError = pysqlite_DatabaseError; + self->DataError = pysqlite_DataError; + self->OperationalError = pysqlite_OperationalError; + self->IntegrityError = pysqlite_IntegrityError; + self->InternalError = pysqlite_InternalError; + self->ProgrammingError = pysqlite_ProgrammingError; + self->NotSupportedError = pysqlite_NotSupportedError; return 0; } /* Empty the entire statement cache of this connection */ -void flush_statement_cache(Connection* self) +void pysqlite_flush_statement_cache(pysqlite_Connection* self) { - Node* node; - Statement* statement; + pysqlite_Node* node; + pysqlite_Statement* statement; node = self->statement_cache->first; while (node) { - statement = (Statement*)(node->data); - (void)statement_finalize(statement); + statement = (pysqlite_Statement*)(node->data); + (void)pysqlite_statement_finalize(statement); node = node->next; } Py_DECREF(self->statement_cache); - self->statement_cache = (Cache*)PyObject_CallFunction((PyObject*)&CacheType, "O", self); + self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "O", self); Py_DECREF(self); self->statement_cache->decref_factory = 0; } -void reset_all_statements(Connection* self) +void pysqlite_reset_all_statements(pysqlite_Connection* self) { int i; PyObject* weakref; @@ -179,12 +179,12 @@ void reset_all_statements(Connection* self) weakref = PyList_GetItem(self->statements, i); statement = PyWeakref_GetObject(weakref); if (statement != Py_None) { - (void)statement_reset((Statement*)statement); + (void)pysqlite_statement_reset((pysqlite_Statement*)statement); } } } -void connection_dealloc(Connection* self) +void pysqlite_connection_dealloc(pysqlite_Connection* self) { Py_XDECREF(self->statement_cache); @@ -208,7 +208,7 @@ void connection_dealloc(Connection* self) self->ob_type->tp_free((PyObject*)self); } -PyObject* connection_cursor(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { static char *kwlist[] = {"factory", NULL, NULL}; PyObject* factory = NULL; @@ -220,34 +220,34 @@ PyObject* connection_cursor(Connection* self, PyObject* args, PyObject* kwargs) return NULL; } - if (!check_thread(self) || !check_connection(self)) { + if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { return NULL; } if (factory == NULL) { - factory = (PyObject*)&CursorType; + factory = (PyObject*)&pysqlite_CursorType; } cursor = PyObject_CallFunction(factory, "O", self); if (cursor && self->row_factory != Py_None) { - Py_XDECREF(((Cursor*)cursor)->row_factory); + Py_XDECREF(((pysqlite_Cursor*)cursor)->row_factory); Py_INCREF(self->row_factory); - ((Cursor*)cursor)->row_factory = self->row_factory; + ((pysqlite_Cursor*)cursor)->row_factory = self->row_factory; } return cursor; } -PyObject* connection_close(Connection* self, PyObject* args) +PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args) { int rc; - if (!check_thread(self)) { + if (!pysqlite_check_thread(self)) { return NULL; } - flush_statement_cache(self); + pysqlite_flush_statement_cache(self); if (self->db) { Py_BEGIN_ALLOW_THREADS @@ -255,7 +255,7 @@ PyObject* connection_close(Connection* self, PyObject* args) Py_END_ALLOW_THREADS if (rc != SQLITE_OK) { - _seterror(self->db); + _pysqlite_seterror(self->db); return NULL; } else { self->db = NULL; @@ -271,17 +271,17 @@ PyObject* connection_close(Connection* self, PyObject* args) * * 0 => error; 1 => ok */ -int check_connection(Connection* con) +int pysqlite_check_connection(pysqlite_Connection* con) { if (!con->db) { - PyErr_SetString(ProgrammingError, "Cannot operate on a closed database."); + PyErr_SetString(pysqlite_ProgrammingError, "Cannot operate on a closed database."); return 0; } else { return 1; } } -PyObject* _connection_begin(Connection* self) +PyObject* _pysqlite_connection_begin(pysqlite_Connection* self) { int rc; const char* tail; @@ -292,7 +292,7 @@ PyObject* _connection_begin(Connection* self) Py_END_ALLOW_THREADS if (rc != SQLITE_OK) { - _seterror(self->db); + _pysqlite_seterror(self->db); goto error; } @@ -300,7 +300,7 @@ PyObject* _connection_begin(Connection* self) if (rc == SQLITE_DONE) { self->inTransaction = 1; } else { - _seterror(self->db); + _pysqlite_seterror(self->db); } Py_BEGIN_ALLOW_THREADS @@ -308,7 +308,7 @@ PyObject* _connection_begin(Connection* self) Py_END_ALLOW_THREADS if (rc != SQLITE_OK && !PyErr_Occurred()) { - _seterror(self->db); + _pysqlite_seterror(self->db); } error: @@ -320,13 +320,13 @@ error: } } -PyObject* connection_commit(Connection* self, PyObject* args) +PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args) { int rc; const char* tail; sqlite3_stmt* statement; - if (!check_thread(self) || !check_connection(self)) { + if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { return NULL; } @@ -335,7 +335,7 @@ PyObject* connection_commit(Connection* self, PyObject* args) rc = sqlite3_prepare(self->db, "COMMIT", -1, &statement, &tail); Py_END_ALLOW_THREADS if (rc != SQLITE_OK) { - _seterror(self->db); + _pysqlite_seterror(self->db); goto error; } @@ -343,14 +343,14 @@ PyObject* connection_commit(Connection* self, PyObject* args) if (rc == SQLITE_DONE) { self->inTransaction = 0; } else { - _seterror(self->db); + _pysqlite_seterror(self->db); } Py_BEGIN_ALLOW_THREADS rc = sqlite3_finalize(statement); Py_END_ALLOW_THREADS if (rc != SQLITE_OK && !PyErr_Occurred()) { - _seterror(self->db); + _pysqlite_seterror(self->db); } } @@ -364,24 +364,24 @@ error: } } -PyObject* connection_rollback(Connection* self, PyObject* args) +PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args) { int rc; const char* tail; sqlite3_stmt* statement; - if (!check_thread(self) || !check_connection(self)) { + if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { return NULL; } if (self->inTransaction) { - reset_all_statements(self); + pysqlite_reset_all_statements(self); Py_BEGIN_ALLOW_THREADS rc = sqlite3_prepare(self->db, "ROLLBACK", -1, &statement, &tail); Py_END_ALLOW_THREADS if (rc != SQLITE_OK) { - _seterror(self->db); + _pysqlite_seterror(self->db); goto error; } @@ -389,14 +389,14 @@ PyObject* connection_rollback(Connection* self, PyObject* args) if (rc == SQLITE_DONE) { self->inTransaction = 0; } else { - _seterror(self->db); + _pysqlite_seterror(self->db); } Py_BEGIN_ALLOW_THREADS rc = sqlite3_finalize(statement); Py_END_ALLOW_THREADS if (rc != SQLITE_OK && !PyErr_Occurred()) { - _seterror(self->db); + _pysqlite_seterror(self->db); } } @@ -410,7 +410,7 @@ error: } } -void _set_result(sqlite3_context* context, PyObject* py_val) +void _pysqlite_set_result(sqlite3_context* context, PyObject* py_val) { long longval; const char* buffer; @@ -445,7 +445,7 @@ void _set_result(sqlite3_context* context, PyObject* py_val) } } -PyObject* _build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv) +PyObject* _pysqlite_build_py_params(sqlite3_context *context, int argc, sqlite3_value** argv) { PyObject* args; int i; @@ -512,7 +512,7 @@ PyObject* _build_py_params(sqlite3_context *context, int argc, sqlite3_value** a return args; } -void _func_callback(sqlite3_context* context, int argc, sqlite3_value** argv) +void _pysqlite_func_callback(sqlite3_context* context, int argc, sqlite3_value** argv) { PyObject* args; PyObject* py_func; @@ -524,14 +524,14 @@ void _func_callback(sqlite3_context* context, int argc, sqlite3_value** argv) py_func = (PyObject*)sqlite3_user_data(context); - args = _build_py_params(context, argc, argv); + args = _pysqlite_build_py_params(context, argc, argv); if (args) { py_retval = PyObject_CallObject(py_func, args); Py_DECREF(args); } if (py_retval) { - _set_result(context, py_retval); + _pysqlite_set_result(context, py_retval); Py_DECREF(py_retval); } else { if (_enable_callback_tracebacks) { @@ -545,7 +545,7 @@ void _func_callback(sqlite3_context* context, int argc, sqlite3_value** argv) PyGILState_Release(threadstate); } -static void _step_callback(sqlite3_context *context, int argc, sqlite3_value** params) +static void _pysqlite_step_callback(sqlite3_context *context, int argc, sqlite3_value** params) { PyObject* args; PyObject* function_result = NULL; @@ -581,7 +581,7 @@ static void _step_callback(sqlite3_context *context, int argc, sqlite3_value** p goto error; } - args = _build_py_params(context, argc, params); + args = _pysqlite_build_py_params(context, argc, params); if (!args) { goto error; } @@ -605,7 +605,7 @@ error: PyGILState_Release(threadstate); } -void _final_callback(sqlite3_context* context) +void _pysqlite_final_callback(sqlite3_context* context) { PyObject* function_result = NULL; PyObject** aggregate_instance; @@ -634,7 +634,7 @@ void _final_callback(sqlite3_context* context) } _sqlite3_result_error(context, "user-defined aggregate's 'finalize' method raised error", -1); } else { - _set_result(context, function_result); + _pysqlite_set_result(context, function_result); } error: @@ -644,7 +644,7 @@ error: PyGILState_Release(threadstate); } -void _drop_unused_statement_references(Connection* self) +void _pysqlite_drop_unused_statement_references(pysqlite_Connection* self) { PyObject* new_list; PyObject* weakref; @@ -676,7 +676,7 @@ void _drop_unused_statement_references(Connection* self) self->statements = new_list; } -PyObject* connection_create_function(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_create_function(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { static char *kwlist[] = {"name", "narg", "func", NULL, NULL}; @@ -691,11 +691,11 @@ PyObject* connection_create_function(Connection* self, PyObject* args, PyObject* return NULL; } - rc = sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _func_callback, NULL, NULL); + rc = sqlite3_create_function(self->db, name, narg, SQLITE_UTF8, (void*)func, _pysqlite_func_callback, NULL, NULL); if (rc != SQLITE_OK) { /* Workaround for SQLite bug: no error code or string is available here */ - PyErr_SetString(OperationalError, "Error creating function"); + PyErr_SetString(pysqlite_OperationalError, "Error creating function"); return NULL; } else { PyDict_SetItem(self->function_pinboard, func, Py_None); @@ -705,7 +705,7 @@ PyObject* connection_create_function(Connection* self, PyObject* args, PyObject* } } -PyObject* connection_create_aggregate(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_create_aggregate(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { PyObject* aggregate_class; @@ -719,10 +719,10 @@ PyObject* connection_create_aggregate(Connection* self, PyObject* args, PyObject return NULL; } - rc = sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_step_callback, &_final_callback); + rc = sqlite3_create_function(self->db, name, n_arg, SQLITE_UTF8, (void*)aggregate_class, 0, &_pysqlite_step_callback, &_pysqlite_final_callback); if (rc != SQLITE_OK) { /* Workaround for SQLite bug: no error code or string is available here */ - PyErr_SetString(OperationalError, "Error creating aggregate"); + PyErr_SetString(pysqlite_OperationalError, "Error creating aggregate"); return NULL; } else { PyDict_SetItem(self->function_pinboard, aggregate_class, Py_None); @@ -732,7 +732,7 @@ PyObject* connection_create_aggregate(Connection* self, PyObject* args, PyObject } } -int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source) +static int _authorizer_callback(void* user_arg, int action, const char* arg1, const char* arg2 , const char* dbname, const char* access_attempt_source) { PyObject *ret; int rc; @@ -762,7 +762,7 @@ int _authorizer_callback(void* user_arg, int action, const char* arg1, const cha return rc; } -PyObject* connection_set_authorizer(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_set_authorizer(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { PyObject* authorizer_cb; @@ -777,7 +777,7 @@ PyObject* connection_set_authorizer(Connection* self, PyObject* args, PyObject* rc = sqlite3_set_authorizer(self->db, _authorizer_callback, (void*)authorizer_cb); if (rc != SQLITE_OK) { - PyErr_SetString(OperationalError, "Error setting authorizer callback"); + PyErr_SetString(pysqlite_OperationalError, "Error setting authorizer callback"); return NULL; } else { PyDict_SetItem(self->function_pinboard, authorizer_cb, Py_None); @@ -787,11 +787,11 @@ PyObject* connection_set_authorizer(Connection* self, PyObject* args, PyObject* } } -int check_thread(Connection* self) +int pysqlite_check_thread(pysqlite_Connection* self) { if (self->check_same_thread) { if (PyThread_get_thread_ident() != self->thread_ident) { - PyErr_Format(ProgrammingError, + PyErr_Format(pysqlite_ProgrammingError, "SQLite objects created in a thread can only be used in that same thread." "The object was created in thread id %ld and this is thread id %ld", self->thread_ident, PyThread_get_thread_ident()); @@ -803,22 +803,22 @@ int check_thread(Connection* self) return 1; } -static PyObject* connection_get_isolation_level(Connection* self, void* unused) +static PyObject* pysqlite_connection_get_isolation_level(pysqlite_Connection* self, void* unused) { Py_INCREF(self->isolation_level); return self->isolation_level; } -static PyObject* connection_get_total_changes(Connection* self, void* unused) +static PyObject* pysqlite_connection_get_total_changes(pysqlite_Connection* self, void* unused) { - if (!check_connection(self)) { + if (!pysqlite_check_connection(self)) { return NULL; } else { return Py_BuildValue("i", sqlite3_total_changes(self->db)); } } -static int connection_set_isolation_level(Connection* self, PyObject* isolation_level) +static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level) { PyObject* res; PyObject* begin_statement; @@ -834,7 +834,7 @@ static int connection_set_isolation_level(Connection* self, PyObject* isolation_ Py_INCREF(Py_None); self->isolation_level = Py_None; - res = connection_commit(self, NULL); + res = pysqlite_connection_commit(self, NULL); if (!res) { return -1; } @@ -866,10 +866,10 @@ static int connection_set_isolation_level(Connection* self, PyObject* isolation_ return 0; } -PyObject* connection_call(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_call(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { PyObject* sql; - Statement* statement; + pysqlite_Statement* statement; PyObject* weakref; int rc; @@ -877,22 +877,22 @@ PyObject* connection_call(Connection* self, PyObject* args, PyObject* kwargs) return NULL; } - _drop_unused_statement_references(self); + _pysqlite_drop_unused_statement_references(self); - statement = PyObject_New(Statement, &StatementType); + statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType); if (!statement) { return NULL; } - rc = statement_create(statement, self, sql); + rc = pysqlite_statement_create(statement, self, sql); if (rc != SQLITE_OK) { if (rc == PYSQLITE_TOO_MUCH_SQL) { - PyErr_SetString(Warning, "You can only execute one statement at a time."); + PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time."); } else if (rc == PYSQLITE_SQL_WRONG_TYPE) { - PyErr_SetString(Warning, "SQL is of wrong type. Must be string or unicode."); + PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string or unicode."); } else { - _seterror(self->db); + _pysqlite_seterror(self->db); } Py_DECREF(statement); @@ -918,7 +918,7 @@ error: return (PyObject*)statement; } -PyObject* connection_execute(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_execute(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { PyObject* cursor = 0; PyObject* result = 0; @@ -949,7 +949,7 @@ error: return cursor; } -PyObject* connection_executemany(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_executemany(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { PyObject* cursor = 0; PyObject* result = 0; @@ -980,7 +980,7 @@ error: return cursor; } -PyObject* connection_executescript(Connection* self, PyObject* args, PyObject* kwargs) +PyObject* pysqlite_connection_executescript(pysqlite_Connection* self, PyObject* args, PyObject* kwargs) { PyObject* cursor = 0; PyObject* result = 0; @@ -1014,7 +1014,7 @@ error: /* ------------------------- COLLATION CODE ------------------------ */ static int -collation_callback( +pysqlite_collation_callback( void* context, int text1_length, const void* text1_data, int text2_length, const void* text2_data) @@ -1063,11 +1063,11 @@ finally: } static PyObject * -connection_interrupt(Connection* self, PyObject* args) +pysqlite_connection_interrupt(pysqlite_Connection* self, PyObject* args) { PyObject* retval = NULL; - if (!check_connection(self)) { + if (!pysqlite_check_connection(self)) { goto finally; } @@ -1081,7 +1081,7 @@ finally: } static PyObject * -connection_create_collation(Connection* self, PyObject* args) +pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args) { PyObject* callable; PyObject* uppercase_name = 0; @@ -1090,7 +1090,7 @@ connection_create_collation(Connection* self, PyObject* args) char* chk; int rc; - if (!check_thread(self) || !check_connection(self)) { + if (!pysqlite_check_thread(self) || !pysqlite_check_connection(self)) { goto finally; } @@ -1111,7 +1111,7 @@ connection_create_collation(Connection* self, PyObject* args) { chk++; } else { - PyErr_SetString(ProgrammingError, "invalid character in collation name"); + PyErr_SetString(pysqlite_ProgrammingError, "invalid character in collation name"); goto finally; } } @@ -1131,10 +1131,10 @@ connection_create_collation(Connection* self, PyObject* args) PyString_AsString(uppercase_name), SQLITE_UTF8, (callable != Py_None) ? callable : NULL, - (callable != Py_None) ? collation_callback : NULL); + (callable != Py_None) ? pysqlite_collation_callback : NULL); if (rc != SQLITE_OK) { PyDict_DelItem(self->collations, uppercase_name); - _seterror(self->db); + _pysqlite_seterror(self->db); goto finally; } @@ -1155,63 +1155,63 @@ static char connection_doc[] = PyDoc_STR("SQLite database connection object."); static PyGetSetDef connection_getset[] = { - {"isolation_level", (getter)connection_get_isolation_level, (setter)connection_set_isolation_level}, - {"total_changes", (getter)connection_get_total_changes, (setter)0}, + {"isolation_level", (getter)pysqlite_connection_get_isolation_level, (setter)pysqlite_connection_set_isolation_level}, + {"total_changes", (getter)pysqlite_connection_get_total_changes, (setter)0}, {NULL} }; static PyMethodDef connection_methods[] = { - {"cursor", (PyCFunction)connection_cursor, METH_VARARGS|METH_KEYWORDS, + {"cursor", (PyCFunction)pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Return a cursor for the connection.")}, - {"close", (PyCFunction)connection_close, METH_NOARGS, + {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS, PyDoc_STR("Closes the connection.")}, - {"commit", (PyCFunction)connection_commit, METH_NOARGS, + {"commit", (PyCFunction)pysqlite_connection_commit, METH_NOARGS, PyDoc_STR("Commit the current transaction.")}, - {"rollback", (PyCFunction)connection_rollback, METH_NOARGS, + {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS, PyDoc_STR("Roll back the current transaction.")}, - {"create_function", (PyCFunction)connection_create_function, METH_VARARGS|METH_KEYWORDS, + {"create_function", (PyCFunction)pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Creates a new function. Non-standard.")}, - {"create_aggregate", (PyCFunction)connection_create_aggregate, METH_VARARGS|METH_KEYWORDS, + {"create_aggregate", (PyCFunction)pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Creates a new aggregate. Non-standard.")}, - {"set_authorizer", (PyCFunction)connection_set_authorizer, METH_VARARGS|METH_KEYWORDS, + {"set_authorizer", (PyCFunction)pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Sets authorizer callback. Non-standard.")}, - {"execute", (PyCFunction)connection_execute, METH_VARARGS, + {"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS, PyDoc_STR("Executes a SQL statement. Non-standard.")}, - {"executemany", (PyCFunction)connection_executemany, METH_VARARGS, + {"executemany", (PyCFunction)pysqlite_connection_executemany, METH_VARARGS, PyDoc_STR("Repeatedly executes a SQL statement. Non-standard.")}, - {"executescript", (PyCFunction)connection_executescript, METH_VARARGS, + {"executescript", (PyCFunction)pysqlite_connection_executescript, METH_VARARGS, PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")}, - {"create_collation", (PyCFunction)connection_create_collation, METH_VARARGS, + {"create_collation", (PyCFunction)pysqlite_connection_create_collation, METH_VARARGS, PyDoc_STR("Creates a collation function. Non-standard.")}, - {"interrupt", (PyCFunction)connection_interrupt, METH_NOARGS, + {"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS, PyDoc_STR("Abort any pending database operation. Non-standard.")}, {NULL, NULL} }; static struct PyMemberDef connection_members[] = { - {"Warning", T_OBJECT, offsetof(Connection, Warning), RO}, - {"Error", T_OBJECT, offsetof(Connection, Error), RO}, - {"InterfaceError", T_OBJECT, offsetof(Connection, InterfaceError), RO}, - {"DatabaseError", T_OBJECT, offsetof(Connection, DatabaseError), RO}, - {"DataError", T_OBJECT, offsetof(Connection, DataError), RO}, - {"OperationalError", T_OBJECT, offsetof(Connection, OperationalError), RO}, - {"IntegrityError", T_OBJECT, offsetof(Connection, IntegrityError), RO}, - {"InternalError", T_OBJECT, offsetof(Connection, InternalError), RO}, - {"ProgrammingError", T_OBJECT, offsetof(Connection, ProgrammingError), RO}, - {"NotSupportedError", T_OBJECT, offsetof(Connection, NotSupportedError), RO}, - {"row_factory", T_OBJECT, offsetof(Connection, row_factory)}, - {"text_factory", T_OBJECT, offsetof(Connection, text_factory)}, + {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), RO}, + {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), RO}, + {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), RO}, + {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), RO}, + {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), RO}, + {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), RO}, + {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), RO}, + {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), RO}, + {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), RO}, + {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), RO}, + {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)}, + {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)}, {NULL} }; -PyTypeObject ConnectionType = { +PyTypeObject pysqlite_ConnectionType = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ MODULE_NAME ".Connection", /* tp_name */ - sizeof(Connection), /* tp_basicsize */ + sizeof(pysqlite_Connection), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)connection_dealloc, /* tp_dealloc */ + (destructor)pysqlite_connection_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ @@ -1221,7 +1221,7 @@ PyTypeObject ConnectionType = { 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ - (ternaryfunc)connection_call, /* tp_call */ + (ternaryfunc)pysqlite_connection_call, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ @@ -1242,14 +1242,14 @@ PyTypeObject ConnectionType = { 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)connection_init, /* tp_init */ + (initproc)pysqlite_connection_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0 /* tp_free */ }; -extern int connection_setup_types(void) +extern int pysqlite_connection_setup_types(void) { - ConnectionType.tp_new = PyType_GenericNew; - return PyType_Ready(&ConnectionType); + pysqlite_ConnectionType.tp_new = PyType_GenericNew; + return PyType_Ready(&pysqlite_ConnectionType); } diff --git a/Modules/_sqlite/connection.h b/Modules/_sqlite/connection.h index 8f4d36e..21fcd2a 100644 --- a/Modules/_sqlite/connection.h +++ b/Modules/_sqlite/connection.h @@ -66,7 +66,7 @@ typedef struct /* thread identification of the thread the connection was created in */ long thread_ident; - Cache* statement_cache; + pysqlite_Cache* statement_cache; /* A list of weak references to statements used within this connection */ PyObject* statements; @@ -106,24 +106,23 @@ typedef struct PyObject* InternalError; PyObject* ProgrammingError; PyObject* NotSupportedError; -} Connection; +} pysqlite_Connection; -extern PyTypeObject ConnectionType; +extern PyTypeObject pysqlite_ConnectionType; -PyObject* connection_alloc(PyTypeObject* type, int aware); -void connection_dealloc(Connection* self); -PyObject* connection_cursor(Connection* self, PyObject* args, PyObject* kwargs); -PyObject* connection_close(Connection* self, PyObject* args); -PyObject* _connection_begin(Connection* self); -PyObject* connection_begin(Connection* self, PyObject* args); -PyObject* connection_commit(Connection* self, PyObject* args); -PyObject* connection_rollback(Connection* self, PyObject* args); -PyObject* connection_new(PyTypeObject* type, PyObject* args, PyObject* kw); -int connection_init(Connection* self, PyObject* args, PyObject* kwargs); +PyObject* pysqlite_connection_alloc(PyTypeObject* type, int aware); +void pysqlite_connection_dealloc(pysqlite_Connection* self); +PyObject* pysqlite_connection_cursor(pysqlite_Connection* self, PyObject* args, PyObject* kwargs); +PyObject* pysqlite_connection_close(pysqlite_Connection* self, PyObject* args); +PyObject* _pysqlite_connection_begin(pysqlite_Connection* self); +PyObject* pysqlite_connection_commit(pysqlite_Connection* self, PyObject* args); +PyObject* pysqlite_connection_rollback(pysqlite_Connection* self, PyObject* args); +PyObject* pysqlite_connection_new(PyTypeObject* type, PyObject* args, PyObject* kw); +int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs); -int check_thread(Connection* self); -int check_connection(Connection* con); +int pysqlite_check_thread(pysqlite_Connection* self); +int pysqlite_check_connection(pysqlite_Connection* con); -int connection_setup_types(void); +int pysqlite_connection_setup_types(void); #endif diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c index 91d8f74..4ca1063 100644 --- a/Modules/_sqlite/cursor.c +++ b/Modules/_sqlite/cursor.c @@ -34,9 +34,9 @@ #define INT32_MAX 2147483647 #endif -PyObject* cursor_iternext(Cursor *self); +PyObject* pysqlite_cursor_iternext(pysqlite_Cursor* self); -static StatementKind detect_statement_type(char* statement) +static pysqlite_StatementKind detect_statement_type(char* statement) { char buf[20]; char* src; @@ -74,11 +74,11 @@ static StatementKind detect_statement_type(char* statement) } } -int cursor_init(Cursor* self, PyObject* args, PyObject* kwargs) +int pysqlite_cursor_init(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs) { - Connection* connection; + pysqlite_Connection* connection; - if (!PyArg_ParseTuple(args, "O!", &ConnectionType, &connection)) + if (!PyArg_ParseTuple(args, "O!", &pysqlite_ConnectionType, &connection)) { return -1; } @@ -109,20 +109,20 @@ int cursor_init(Cursor* self, PyObject* args, PyObject* kwargs) Py_INCREF(Py_None); self->row_factory = Py_None; - if (!check_thread(self->connection)) { + if (!pysqlite_check_thread(self->connection)) { return -1; } return 0; } -void cursor_dealloc(Cursor* self) +void pysqlite_cursor_dealloc(pysqlite_Cursor* self) { int rc; /* Reset the statement if the user has not closed the cursor */ if (self->statement) { - rc = statement_reset(self->statement); + rc = pysqlite_statement_reset(self->statement); Py_DECREF(self->statement); } @@ -137,7 +137,7 @@ void cursor_dealloc(Cursor* self) self->ob_type->tp_free((PyObject*)self); } -PyObject* _get_converter(PyObject* key) +PyObject* _pysqlite_get_converter(PyObject* key) { PyObject* upcase_key; PyObject* retval; @@ -153,7 +153,7 @@ PyObject* _get_converter(PyObject* key) return retval; } -int build_row_cast_map(Cursor* self) +int pysqlite_build_row_cast_map(pysqlite_Cursor* self) { int i; const char* type_start = (const char*)-1; @@ -175,7 +175,7 @@ int build_row_cast_map(Cursor* self) for (i = 0; i < sqlite3_column_count(self->statement->st); i++) { converter = NULL; - if (self->connection->detect_types | PARSE_COLNAMES) { + if (self->connection->detect_types & PARSE_COLNAMES) { colname = sqlite3_column_name(self->statement->st, i); if (colname) { for (pos = colname; *pos != 0; pos++) { @@ -190,7 +190,7 @@ int build_row_cast_map(Cursor* self) break; } - converter = _get_converter(key); + converter = _pysqlite_get_converter(key); Py_DECREF(key); break; } @@ -198,7 +198,7 @@ int build_row_cast_map(Cursor* self) } } - if (!converter && self->connection->detect_types | PARSE_DECLTYPES) { + if (!converter && self->connection->detect_types & PARSE_DECLTYPES) { decltype = sqlite3_column_decltype(self->statement->st, i); if (decltype) { for (pos = decltype;;pos++) { @@ -211,7 +211,7 @@ int build_row_cast_map(Cursor* self) } } - converter = _get_converter(py_decltype); + converter = _pysqlite_get_converter(py_decltype); Py_DECREF(py_decltype); } } @@ -234,7 +234,7 @@ int build_row_cast_map(Cursor* self) return 0; } -PyObject* _build_column_name(const char* colname) +PyObject* _pysqlite_build_column_name(const char* colname) { const char* pos; @@ -253,7 +253,7 @@ PyObject* _build_column_name(const char* colname) } } -PyObject* unicode_from_string(const char* val_str, int optimize) +PyObject* pysqlite_unicode_from_string(const char* val_str, int optimize) { const char* check; int is_ascii = 0; @@ -285,7 +285,7 @@ PyObject* unicode_from_string(const char* val_str, int optimize) * Precondidition: * - sqlite3_step() has been called before and it returned SQLITE_ROW. */ -PyObject* _fetch_one_row(Cursor* self) +PyObject* _pysqlite_fetch_one_row(pysqlite_Cursor* self) { int i, numcols; PyObject* row; @@ -356,10 +356,10 @@ PyObject* _fetch_one_row(Cursor* self) } else if (coltype == SQLITE_TEXT) { val_str = (const char*)sqlite3_column_text(self->statement->st, i); if ((self->connection->text_factory == (PyObject*)&PyUnicode_Type) - || (self->connection->text_factory == OptimizedUnicode)) { + || (self->connection->text_factory == pysqlite_OptimizedUnicode)) { - converted = unicode_from_string(val_str, - self->connection->text_factory == OptimizedUnicode ? 1 : 0); + converted = pysqlite_unicode_from_string(val_str, + self->connection->text_factory == pysqlite_OptimizedUnicode ? 1 : 0); if (!converted) { colname = sqlite3_column_name(self->statement->st, i); @@ -368,7 +368,7 @@ PyObject* _fetch_one_row(Cursor* self) } PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'", colname , val_str); - PyErr_SetString(OperationalError, buf); + PyErr_SetString(pysqlite_OperationalError, buf); } } else if (self->connection->text_factory == (PyObject*)&PyString_Type) { converted = PyString_FromString(val_str); @@ -406,7 +406,7 @@ PyObject* _fetch_one_row(Cursor* self) return row; } -PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) +PyObject* _pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* args) { PyObject* operation; PyObject* operation_bytestr = NULL; @@ -425,7 +425,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) PyObject* second_argument = NULL; long rowcount = 0; - if (!check_thread(self->connection) || !check_connection(self->connection)) { + if (!pysqlite_check_thread(self->connection) || !pysqlite_check_connection(self->connection)) { return NULL; } @@ -492,7 +492,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) if (self->statement != NULL) { /* There is an active statement */ - rc = statement_reset(self->statement); + rc = pysqlite_statement_reset(self->statement); } if (PyString_Check(operation)) { @@ -525,7 +525,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) case STATEMENT_INSERT: case STATEMENT_REPLACE: if (!self->connection->inTransaction) { - result = _connection_begin(self->connection); + result = _pysqlite_connection_begin(self->connection); if (!result) { goto error; } @@ -536,7 +536,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) /* it's a DDL statement or something similar - we better COMMIT first so it works for all cases */ if (self->connection->inTransaction) { - result = connection_commit(self->connection, NULL); + result = pysqlite_connection_commit(self->connection, NULL); if (!result) { goto error; } @@ -545,7 +545,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) break; case STATEMENT_SELECT: if (multiple) { - PyErr_SetString(ProgrammingError, + PyErr_SetString(pysqlite_ProgrammingError, "You cannot execute SELECT statements in executemany()."); goto error; } @@ -563,11 +563,11 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) } if (self->statement) { - (void)statement_reset(self->statement); + (void)pysqlite_statement_reset(self->statement); Py_DECREF(self->statement); } - self->statement = (Statement*)cache_get(self->connection->statement_cache, func_args); + self->statement = (pysqlite_Statement*)pysqlite_cache_get(self->connection->statement_cache, func_args); Py_DECREF(func_args); if (!self->statement) { @@ -576,19 +576,19 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) if (self->statement->in_use) { Py_DECREF(self->statement); - self->statement = PyObject_New(Statement, &StatementType); + self->statement = PyObject_New(pysqlite_Statement, &pysqlite_StatementType); if (!self->statement) { goto error; } - rc = statement_create(self->statement, self->connection, operation); + rc = pysqlite_statement_create(self->statement, self->connection, operation); if (rc != SQLITE_OK) { self->statement = 0; goto error; } } - statement_reset(self->statement); - statement_mark_dirty(self->statement); + pysqlite_statement_reset(self->statement); + pysqlite_statement_mark_dirty(self->statement); while (1) { parameters = PyIter_Next(parameters_iter); @@ -596,27 +596,37 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) break; } - statement_mark_dirty(self->statement); + pysqlite_statement_mark_dirty(self->statement); - statement_bind_parameters(self->statement, parameters); + pysqlite_statement_bind_parameters(self->statement, parameters); if (PyErr_Occurred()) { goto error; } - if (build_row_cast_map(self) != 0) { - PyErr_SetString(OperationalError, "Error while building row_cast_map"); + if (pysqlite_build_row_cast_map(self) != 0) { + PyErr_SetString(pysqlite_OperationalError, "Error while building row_cast_map"); goto error; } - rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection); - if (rc != SQLITE_DONE && rc != SQLITE_ROW) { - rc = statement_reset(self->statement); + /* Keep trying the SQL statement until the schema stops changing. */ + while (1) { + /* Actually execute the SQL statement. */ + rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection); + if (rc == SQLITE_DONE || rc == SQLITE_ROW) { + /* If it worked, let's get out of the loop */ + break; + } + /* Something went wrong. Re-set the statement and try again. */ + rc = pysqlite_statement_reset(self->statement); if (rc == SQLITE_SCHEMA) { - rc = statement_recompile(self->statement, parameters); + /* If this was a result of the schema changing, let's try + again. */ + rc = pysqlite_statement_recompile(self->statement, parameters); if (rc == SQLITE_OK) { - rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection); + continue; } else { - _seterror(self->connection->db); + /* If the database gave us an error, promote it to Python. */ + _pysqlite_seterror(self->connection->db); goto error; } } else { @@ -628,7 +638,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) PyErr_Clear(); } } - _seterror(self->connection->db); + _pysqlite_seterror(self->connection->db); goto error; } } @@ -649,7 +659,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) if (!descriptor) { goto error; } - PyTuple_SetItem(descriptor, 0, _build_column_name(sqlite3_column_name(self->statement->st, i))); + PyTuple_SetItem(descriptor, 0, _pysqlite_build_column_name(sqlite3_column_name(self->statement->st, i))); Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 1, Py_None); Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 2, Py_None); Py_INCREF(Py_None); PyTuple_SetItem(descriptor, 3, Py_None); @@ -663,13 +673,13 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) if (rc == SQLITE_ROW) { if (multiple) { - PyErr_SetString(ProgrammingError, "executemany() can only execute DML statements."); + PyErr_SetString(pysqlite_ProgrammingError, "executemany() can only execute DML statements."); goto error; } - self->next_row = _fetch_one_row(self); + self->next_row = _pysqlite_fetch_one_row(self); } else if (rc == SQLITE_DONE && !multiple) { - statement_reset(self->statement); + pysqlite_statement_reset(self->statement); Py_DECREF(self->statement); self->statement = 0; } @@ -698,7 +708,7 @@ PyObject* _query_execute(Cursor* self, int multiple, PyObject* args) } if (multiple) { - rc = statement_reset(self->statement); + rc = pysqlite_statement_reset(self->statement); } Py_XDECREF(parameters); } @@ -717,17 +727,17 @@ error: } } -PyObject* cursor_execute(Cursor* self, PyObject* args) +PyObject* pysqlite_cursor_execute(pysqlite_Cursor* self, PyObject* args) { - return _query_execute(self, 0, args); + return _pysqlite_query_execute(self, 0, args); } -PyObject* cursor_executemany(Cursor* self, PyObject* args) +PyObject* pysqlite_cursor_executemany(pysqlite_Cursor* self, PyObject* args) { - return _query_execute(self, 1, args); + return _pysqlite_query_execute(self, 1, args); } -PyObject* cursor_executescript(Cursor* self, PyObject* args) +PyObject* pysqlite_cursor_executescript(pysqlite_Cursor* self, PyObject* args) { PyObject* script_obj; PyObject* script_str = NULL; @@ -741,7 +751,7 @@ PyObject* cursor_executescript(Cursor* self, PyObject* args) return NULL; } - if (!check_thread(self->connection) || !check_connection(self->connection)) { + if (!pysqlite_check_thread(self->connection) || !pysqlite_check_connection(self->connection)) { return NULL; } @@ -760,7 +770,7 @@ PyObject* cursor_executescript(Cursor* self, PyObject* args) } /* commit first */ - result = connection_commit(self->connection, NULL); + result = pysqlite_connection_commit(self->connection, NULL); if (!result) { goto error; } @@ -778,7 +788,7 @@ PyObject* cursor_executescript(Cursor* self, PyObject* args) &statement, &script_cstr); if (rc != SQLITE_OK) { - _seterror(self->connection->db); + _pysqlite_seterror(self->connection->db); goto error; } @@ -790,13 +800,13 @@ PyObject* cursor_executescript(Cursor* self, PyObject* args) if (rc != SQLITE_DONE) { (void)sqlite3_finalize(statement); - _seterror(self->connection->db); + _pysqlite_seterror(self->connection->db); goto error; } rc = sqlite3_finalize(statement); if (rc != SQLITE_OK) { - _seterror(self->connection->db); + _pysqlite_seterror(self->connection->db); goto error; } } @@ -805,7 +815,7 @@ error: Py_XDECREF(script_str); if (!statement_completed) { - PyErr_SetString(ProgrammingError, "you did not provide a complete SQL statement"); + PyErr_SetString(pysqlite_ProgrammingError, "you did not provide a complete SQL statement"); } if (PyErr_Occurred()) { @@ -816,25 +826,25 @@ error: } } -PyObject* cursor_getiter(Cursor *self) +PyObject* pysqlite_cursor_getiter(pysqlite_Cursor *self) { Py_INCREF(self); return (PyObject*)self; } -PyObject* cursor_iternext(Cursor *self) +PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self) { PyObject* next_row_tuple; PyObject* next_row; int rc; - if (!check_thread(self->connection) || !check_connection(self->connection)) { + if (!pysqlite_check_thread(self->connection) || !pysqlite_check_connection(self->connection)) { return NULL; } if (!self->next_row) { if (self->statement) { - (void)statement_reset(self->statement); + (void)pysqlite_statement_reset(self->statement); Py_DECREF(self->statement); self->statement = NULL; } @@ -851,25 +861,27 @@ PyObject* cursor_iternext(Cursor *self) next_row = next_row_tuple; } - rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection); - if (rc != SQLITE_DONE && rc != SQLITE_ROW) { - Py_DECREF(next_row); - _seterror(self->connection->db); - return NULL; - } + if (self->statement) { + rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection); + if (rc != SQLITE_DONE && rc != SQLITE_ROW) { + Py_DECREF(next_row); + _pysqlite_seterror(self->connection->db); + return NULL; + } - if (rc == SQLITE_ROW) { - self->next_row = _fetch_one_row(self); + if (rc == SQLITE_ROW) { + self->next_row = _pysqlite_fetch_one_row(self); + } } return next_row; } -PyObject* cursor_fetchone(Cursor* self, PyObject* args) +PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args) { PyObject* row; - row = cursor_iternext(self); + row = pysqlite_cursor_iternext(self); if (!row && !PyErr_Occurred()) { Py_INCREF(Py_None); return Py_None; @@ -878,7 +890,7 @@ PyObject* cursor_fetchone(Cursor* self, PyObject* args) return row; } -PyObject* cursor_fetchmany(Cursor* self, PyObject* args) +PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args) { PyObject* row; PyObject* list; @@ -898,7 +910,7 @@ PyObject* cursor_fetchmany(Cursor* self, PyObject* args) row = Py_None; while (row) { - row = cursor_iternext(self); + row = pysqlite_cursor_iternext(self); if (row) { PyList_Append(list, row); Py_DECREF(row); @@ -919,7 +931,7 @@ PyObject* cursor_fetchmany(Cursor* self, PyObject* args) } } -PyObject* cursor_fetchall(Cursor* self, PyObject* args) +PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args) { PyObject* row; PyObject* list; @@ -933,7 +945,7 @@ PyObject* cursor_fetchall(Cursor* self, PyObject* args) row = (PyObject*)Py_None; while (row) { - row = cursor_iternext(self); + row = pysqlite_cursor_iternext(self); if (row) { PyList_Append(list, row); Py_DECREF(row); @@ -948,21 +960,21 @@ PyObject* cursor_fetchall(Cursor* self, PyObject* args) } } -PyObject* pysqlite_noop(Connection* self, PyObject* args) +PyObject* pysqlite_noop(pysqlite_Connection* self, PyObject* args) { /* don't care, return None */ Py_INCREF(Py_None); return Py_None; } -PyObject* cursor_close(Cursor* self, PyObject* args) +PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args) { - if (!check_thread(self->connection) || !check_connection(self->connection)) { + if (!pysqlite_check_thread(self->connection) || !pysqlite_check_connection(self->connection)) { return NULL; } if (self->statement) { - (void)statement_reset(self->statement); + (void)pysqlite_statement_reset(self->statement); Py_DECREF(self->statement); self->statement = 0; } @@ -972,19 +984,19 @@ PyObject* cursor_close(Cursor* self, PyObject* args) } static PyMethodDef cursor_methods[] = { - {"execute", (PyCFunction)cursor_execute, METH_VARARGS, + {"execute", (PyCFunction)pysqlite_cursor_execute, METH_VARARGS, PyDoc_STR("Executes a SQL statement.")}, - {"executemany", (PyCFunction)cursor_executemany, METH_VARARGS, + {"executemany", (PyCFunction)pysqlite_cursor_executemany, METH_VARARGS, PyDoc_STR("Repeatedly executes a SQL statement.")}, - {"executescript", (PyCFunction)cursor_executescript, METH_VARARGS, + {"executescript", (PyCFunction)pysqlite_cursor_executescript, METH_VARARGS, PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")}, - {"fetchone", (PyCFunction)cursor_fetchone, METH_NOARGS, + {"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS, PyDoc_STR("Fetches several rows from the resultset.")}, - {"fetchmany", (PyCFunction)cursor_fetchmany, METH_VARARGS, + {"fetchmany", (PyCFunction)pysqlite_cursor_fetchmany, METH_VARARGS, PyDoc_STR("Fetches all rows from the resultset.")}, - {"fetchall", (PyCFunction)cursor_fetchall, METH_NOARGS, + {"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS, PyDoc_STR("Fetches one row from the resultset.")}, - {"close", (PyCFunction)cursor_close, METH_NOARGS, + {"close", (PyCFunction)pysqlite_cursor_close, METH_NOARGS, PyDoc_STR("Closes the cursor.")}, {"setinputsizes", (PyCFunction)pysqlite_noop, METH_VARARGS, PyDoc_STR("Required by DB-API. Does nothing in pysqlite.")}, @@ -995,25 +1007,25 @@ static PyMethodDef cursor_methods[] = { static struct PyMemberDef cursor_members[] = { - {"connection", T_OBJECT, offsetof(Cursor, connection), RO}, - {"description", T_OBJECT, offsetof(Cursor, description), RO}, - {"arraysize", T_INT, offsetof(Cursor, arraysize), 0}, - {"lastrowid", T_OBJECT, offsetof(Cursor, lastrowid), RO}, - {"rowcount", T_OBJECT, offsetof(Cursor, rowcount), RO}, - {"row_factory", T_OBJECT, offsetof(Cursor, row_factory), 0}, + {"connection", T_OBJECT, offsetof(pysqlite_Cursor, connection), RO}, + {"description", T_OBJECT, offsetof(pysqlite_Cursor, description), RO}, + {"arraysize", T_INT, offsetof(pysqlite_Cursor, arraysize), 0}, + {"lastrowid", T_OBJECT, offsetof(pysqlite_Cursor, lastrowid), RO}, + {"rowcount", T_OBJECT, offsetof(pysqlite_Cursor, rowcount), RO}, + {"row_factory", T_OBJECT, offsetof(pysqlite_Cursor, row_factory), 0}, {NULL} }; static char cursor_doc[] = PyDoc_STR("SQLite database cursor class."); -PyTypeObject CursorType = { +PyTypeObject pysqlite_CursorType = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ MODULE_NAME ".Cursor", /* tp_name */ - sizeof(Cursor), /* tp_basicsize */ + sizeof(pysqlite_Cursor), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)cursor_dealloc, /* tp_dealloc */ + (destructor)pysqlite_cursor_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ @@ -1034,8 +1046,8 @@ PyTypeObject CursorType = { 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ - (getiterfunc)cursor_getiter, /* tp_iter */ - (iternextfunc)cursor_iternext, /* tp_iternext */ + (getiterfunc)pysqlite_cursor_getiter, /* tp_iter */ + (iternextfunc)pysqlite_cursor_iternext, /* tp_iternext */ cursor_methods, /* tp_methods */ cursor_members, /* tp_members */ 0, /* tp_getset */ @@ -1044,14 +1056,14 @@ PyTypeObject CursorType = { 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)cursor_init, /* tp_init */ + (initproc)pysqlite_cursor_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0 /* tp_free */ }; -extern int cursor_setup_types(void) +extern int pysqlite_cursor_setup_types(void) { - CursorType.tp_new = PyType_GenericNew; - return PyType_Ready(&CursorType); + pysqlite_CursorType.tp_new = PyType_GenericNew; + return PyType_Ready(&pysqlite_CursorType); } diff --git a/Modules/_sqlite/cursor.h b/Modules/_sqlite/cursor.h index 831ff81..5fce64a 100644 --- a/Modules/_sqlite/cursor.h +++ b/Modules/_sqlite/cursor.h @@ -32,40 +32,40 @@ typedef struct { PyObject_HEAD - Connection* connection; + pysqlite_Connection* connection; PyObject* description; PyObject* row_cast_map; int arraysize; PyObject* lastrowid; PyObject* rowcount; PyObject* row_factory; - Statement* statement; + pysqlite_Statement* statement; /* the next row to be returned, NULL if no next row available */ PyObject* next_row; -} Cursor; +} pysqlite_Cursor; typedef enum { STATEMENT_INVALID, STATEMENT_INSERT, STATEMENT_DELETE, STATEMENT_UPDATE, STATEMENT_REPLACE, STATEMENT_SELECT, STATEMENT_OTHER -} StatementKind; +} pysqlite_StatementKind; -extern PyTypeObject CursorType; +extern PyTypeObject pysqlite_CursorType; -int cursor_init(Cursor* self, PyObject* args, PyObject* kwargs); -void cursor_dealloc(Cursor* self); -PyObject* cursor_execute(Cursor* self, PyObject* args); -PyObject* cursor_executemany(Cursor* self, PyObject* args); -PyObject* cursor_getiter(Cursor *self); -PyObject* cursor_iternext(Cursor *self); -PyObject* cursor_fetchone(Cursor* self, PyObject* args); -PyObject* cursor_fetchmany(Cursor* self, PyObject* args); -PyObject* cursor_fetchall(Cursor* self, PyObject* args); -PyObject* pysqlite_noop(Connection* self, PyObject* args); -PyObject* cursor_close(Cursor* self, PyObject* args); +int pysqlite_cursor_init(pysqlite_Cursor* self, PyObject* args, PyObject* kwargs); +void pysqlite_cursor_dealloc(pysqlite_Cursor* self); +PyObject* pysqlite_cursor_execute(pysqlite_Cursor* self, PyObject* args); +PyObject* pysqlite_cursor_executemany(pysqlite_Cursor* self, PyObject* args); +PyObject* pysqlite_cursor_getiter(pysqlite_Cursor *self); +PyObject* pysqlite_cursor_iternext(pysqlite_Cursor *self); +PyObject* pysqlite_cursor_fetchone(pysqlite_Cursor* self, PyObject* args); +PyObject* pysqlite_cursor_fetchmany(pysqlite_Cursor* self, PyObject* args); +PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args); +PyObject* pysqlite_noop(pysqlite_Connection* self, PyObject* args); +PyObject* pysqlite_cursor_close(pysqlite_Cursor* self, PyObject* args); -int cursor_setup_types(void); +int pysqlite_cursor_setup_types(void); #define UNKNOWN (-1) #endif diff --git a/Modules/_sqlite/microprotocols.c b/Modules/_sqlite/microprotocols.c index 4956ac0..5a78917 100644 --- a/Modules/_sqlite/microprotocols.c +++ b/Modules/_sqlite/microprotocols.c @@ -57,7 +57,7 @@ microprotocols_add(PyTypeObject *type, PyObject *proto, PyObject *cast) PyObject* key; int rc; - if (proto == NULL) proto = (PyObject*)&SQLitePrepareProtocolType; + if (proto == NULL) proto = (PyObject*)&pysqlite_PrepareProtocolType; key = Py_BuildValue("(OO)", (PyObject*)type, proto); if (!key) { @@ -78,7 +78,7 @@ microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt) PyObject *adapter, *key; /* we don't check for exact type conformance as specified in PEP 246 - because the SQLitePrepareProtocolType type is abstract and there is no + because the pysqlite_PrepareProtocolType type is abstract and there is no way to get a quotable object to be its instance */ /* look for an adapter in the registry */ @@ -125,17 +125,17 @@ microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt) } /* else set the right exception and return NULL */ - PyErr_SetString(ProgrammingError, "can't adapt"); + PyErr_SetString(pysqlite_ProgrammingError, "can't adapt"); return NULL; } /** module-level functions **/ PyObject * -psyco_microprotocols_adapt(Cursor *self, PyObject *args) +psyco_microprotocols_adapt(pysqlite_Cursor *self, PyObject *args) { PyObject *obj, *alt = NULL; - PyObject *proto = (PyObject*)&SQLitePrepareProtocolType; + PyObject *proto = (PyObject*)&pysqlite_PrepareProtocolType; if (!PyArg_ParseTuple(args, "O|OO", &obj, &proto, &alt)) return NULL; return microprotocols_adapt(obj, proto, alt); diff --git a/Modules/_sqlite/microprotocols.h b/Modules/_sqlite/microprotocols.h index f601bb3..d84ec93 100644 --- a/Modules/_sqlite/microprotocols.h +++ b/Modules/_sqlite/microprotocols.h @@ -52,7 +52,7 @@ extern PyObject *microprotocols_adapt( PyObject *obj, PyObject *proto, PyObject *alt); extern PyObject * - psyco_microprotocols_adapt(Cursor* self, PyObject *args); + psyco_microprotocols_adapt(pysqlite_Cursor* self, PyObject *args); #define psyco_microprotocols_adapt_doc \ "adapt(obj, protocol, alternate) -> adapt obj to given protocol. Non-standard." diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c index 606454c..8844d81 100644 --- a/Modules/_sqlite/module.c +++ b/Modules/_sqlite/module.c @@ -35,9 +35,9 @@ /* static objects at module-level */ -PyObject* Error, *Warning, *InterfaceError, *DatabaseError, *InternalError, - *OperationalError, *ProgrammingError, *IntegrityError, *DataError, - *NotSupportedError, *OptimizedUnicode; +PyObject* pysqlite_Error, *pysqlite_Warning, *pysqlite_InterfaceError, *pysqlite_DatabaseError, + *pysqlite_InternalError, *pysqlite_OperationalError, *pysqlite_ProgrammingError, + *pysqlite_IntegrityError, *pysqlite_DataError, *pysqlite_NotSupportedError, *pysqlite_OptimizedUnicode; PyObject* converters; int _enable_callback_tracebacks; @@ -67,7 +67,7 @@ static PyObject* module_connect(PyObject* self, PyObject* args, PyObject* } if (factory == NULL) { - factory = (PyObject*)&ConnectionType; + factory = (PyObject*)&pysqlite_ConnectionType; } result = PyObject_Call(factory, args, kwargs); @@ -115,7 +115,7 @@ static PyObject* module_enable_shared_cache(PyObject* self, PyObject* args, PyOb rc = sqlite3_enable_shared_cache(do_enable); if (rc != SQLITE_OK) { - PyErr_SetString(OperationalError, "Changing the shared_cache flag failed"); + PyErr_SetString(pysqlite_OperationalError, "Changing the shared_cache flag failed"); return NULL; } else { Py_INCREF(Py_None); @@ -133,7 +133,7 @@ static PyObject* module_register_adapter(PyObject* self, PyObject* args, PyObjec return NULL; } - microprotocols_add(type, (PyObject*)&SQLitePrepareProtocolType, caster); + microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster); Py_INCREF(Py_None); return Py_None; @@ -141,36 +141,29 @@ static PyObject* module_register_adapter(PyObject* self, PyObject* args, PyObjec static PyObject* module_register_converter(PyObject* self, PyObject* args, PyObject* kwargs) { - char* orig_name; - char* name = NULL; - char* c; + PyObject* orig_name; + PyObject* name = NULL; PyObject* callable; PyObject* retval = NULL; - if (!PyArg_ParseTuple(args, "sO", &orig_name, &callable)) { + if (!PyArg_ParseTuple(args, "SO", &orig_name, &callable)) { return NULL; } - /* convert the name to lowercase */ - name = PyMem_Malloc(strlen(orig_name) + 2); + /* convert the name to upper case */ + name = PyObject_CallMethod(orig_name, "upper", ""); if (!name) { goto error; } - strcpy(name, orig_name); - for (c = name; *c != (char)0; c++) { - *c = (*c) & 0xDF; - } - if (PyDict_SetItemString(converters, name, callable) != 0) { + if (PyDict_SetItem(converters, name, callable) != 0) { goto error; } Py_INCREF(Py_None); retval = Py_None; error: - if (name) { - PyMem_Free(name); - } + Py_XDECREF(name); return retval; } @@ -184,7 +177,7 @@ static PyObject* enable_callback_tracebacks(PyObject* self, PyObject* args, PyOb return Py_None; } -void converters_init(PyObject* dict) +static void converters_init(PyObject* dict) { converters = PyDict_New(); if (!converters) { @@ -265,28 +258,28 @@ PyMODINIT_FUNC init_sqlite3(void) module = Py_InitModule("_sqlite3", module_methods); if (!module || - (row_setup_types() < 0) || - (cursor_setup_types() < 0) || - (connection_setup_types() < 0) || - (cache_setup_types() < 0) || - (statement_setup_types() < 0) || - (prepare_protocol_setup_types() < 0) + (pysqlite_row_setup_types() < 0) || + (pysqlite_cursor_setup_types() < 0) || + (pysqlite_connection_setup_types() < 0) || + (pysqlite_cache_setup_types() < 0) || + (pysqlite_statement_setup_types() < 0) || + (pysqlite_prepare_protocol_setup_types() < 0) ) { return; } - Py_INCREF(&ConnectionType); - PyModule_AddObject(module, "Connection", (PyObject*) &ConnectionType); - Py_INCREF(&CursorType); - PyModule_AddObject(module, "Cursor", (PyObject*) &CursorType); - Py_INCREF(&CacheType); - PyModule_AddObject(module, "Statement", (PyObject*)&StatementType); - Py_INCREF(&StatementType); - PyModule_AddObject(module, "Cache", (PyObject*) &CacheType); - Py_INCREF(&SQLitePrepareProtocolType); - PyModule_AddObject(module, "PrepareProtocol", (PyObject*) &SQLitePrepareProtocolType); - Py_INCREF(&RowType); - PyModule_AddObject(module, "Row", (PyObject*) &RowType); + Py_INCREF(&pysqlite_ConnectionType); + PyModule_AddObject(module, "Connection", (PyObject*) &pysqlite_ConnectionType); + Py_INCREF(&pysqlite_CursorType); + PyModule_AddObject(module, "Cursor", (PyObject*) &pysqlite_CursorType); + Py_INCREF(&pysqlite_CacheType); + PyModule_AddObject(module, "Statement", (PyObject*)&pysqlite_StatementType); + Py_INCREF(&pysqlite_StatementType); + PyModule_AddObject(module, "Cache", (PyObject*) &pysqlite_CacheType); + Py_INCREF(&pysqlite_PrepareProtocolType); + PyModule_AddObject(module, "PrepareProtocol", (PyObject*) &pysqlite_PrepareProtocolType); + Py_INCREF(&pysqlite_RowType); + PyModule_AddObject(module, "Row", (PyObject*) &pysqlite_RowType); if (!(dict = PyModule_GetDict(module))) { goto error; @@ -294,67 +287,67 @@ PyMODINIT_FUNC init_sqlite3(void) /*** Create DB-API Exception hierarchy */ - if (!(Error = PyErr_NewException(MODULE_NAME ".Error", PyExc_StandardError, NULL))) { + if (!(pysqlite_Error = PyErr_NewException(MODULE_NAME ".Error", PyExc_StandardError, NULL))) { goto error; } - PyDict_SetItemString(dict, "Error", Error); + PyDict_SetItemString(dict, "Error", pysqlite_Error); - if (!(Warning = PyErr_NewException(MODULE_NAME ".Warning", PyExc_StandardError, NULL))) { + if (!(pysqlite_Warning = PyErr_NewException(MODULE_NAME ".Warning", PyExc_StandardError, NULL))) { goto error; } - PyDict_SetItemString(dict, "Warning", Warning); + PyDict_SetItemString(dict, "Warning", pysqlite_Warning); /* Error subclasses */ - if (!(InterfaceError = PyErr_NewException(MODULE_NAME ".InterfaceError", Error, NULL))) { + if (!(pysqlite_InterfaceError = PyErr_NewException(MODULE_NAME ".InterfaceError", pysqlite_Error, NULL))) { goto error; } - PyDict_SetItemString(dict, "InterfaceError", InterfaceError); + PyDict_SetItemString(dict, "InterfaceError", pysqlite_InterfaceError); - if (!(DatabaseError = PyErr_NewException(MODULE_NAME ".DatabaseError", Error, NULL))) { + if (!(pysqlite_DatabaseError = PyErr_NewException(MODULE_NAME ".DatabaseError", pysqlite_Error, NULL))) { goto error; } - PyDict_SetItemString(dict, "DatabaseError", DatabaseError); + PyDict_SetItemString(dict, "DatabaseError", pysqlite_DatabaseError); - /* DatabaseError subclasses */ + /* pysqlite_DatabaseError subclasses */ - if (!(InternalError = PyErr_NewException(MODULE_NAME ".InternalError", DatabaseError, NULL))) { + if (!(pysqlite_InternalError = PyErr_NewException(MODULE_NAME ".InternalError", pysqlite_DatabaseError, NULL))) { goto error; } - PyDict_SetItemString(dict, "InternalError", InternalError); + PyDict_SetItemString(dict, "InternalError", pysqlite_InternalError); - if (!(OperationalError = PyErr_NewException(MODULE_NAME ".OperationalError", DatabaseError, NULL))) { + if (!(pysqlite_OperationalError = PyErr_NewException(MODULE_NAME ".OperationalError", pysqlite_DatabaseError, NULL))) { goto error; } - PyDict_SetItemString(dict, "OperationalError", OperationalError); + PyDict_SetItemString(dict, "OperationalError", pysqlite_OperationalError); - if (!(ProgrammingError = PyErr_NewException(MODULE_NAME ".ProgrammingError", DatabaseError, NULL))) { + if (!(pysqlite_ProgrammingError = PyErr_NewException(MODULE_NAME ".ProgrammingError", pysqlite_DatabaseError, NULL))) { goto error; } - PyDict_SetItemString(dict, "ProgrammingError", ProgrammingError); + PyDict_SetItemString(dict, "ProgrammingError", pysqlite_ProgrammingError); - if (!(IntegrityError = PyErr_NewException(MODULE_NAME ".IntegrityError", DatabaseError,NULL))) { + if (!(pysqlite_IntegrityError = PyErr_NewException(MODULE_NAME ".IntegrityError", pysqlite_DatabaseError,NULL))) { goto error; } - PyDict_SetItemString(dict, "IntegrityError", IntegrityError); + PyDict_SetItemString(dict, "IntegrityError", pysqlite_IntegrityError); - if (!(DataError = PyErr_NewException(MODULE_NAME ".DataError", DatabaseError, NULL))) { + if (!(pysqlite_DataError = PyErr_NewException(MODULE_NAME ".DataError", pysqlite_DatabaseError, NULL))) { goto error; } - PyDict_SetItemString(dict, "DataError", DataError); + PyDict_SetItemString(dict, "DataError", pysqlite_DataError); - if (!(NotSupportedError = PyErr_NewException(MODULE_NAME ".NotSupportedError", DatabaseError, NULL))) { + if (!(pysqlite_NotSupportedError = PyErr_NewException(MODULE_NAME ".NotSupportedError", pysqlite_DatabaseError, NULL))) { goto error; } - PyDict_SetItemString(dict, "NotSupportedError", NotSupportedError); + PyDict_SetItemString(dict, "NotSupportedError", pysqlite_NotSupportedError); - /* We just need "something" unique for OptimizedUnicode. It does not really + /* We just need "something" unique for pysqlite_OptimizedUnicode. It does not really * need to be a string subclass. Just anything that can act as a special * marker for us. So I pulled PyCell_Type out of my magic hat. */ Py_INCREF((PyObject*)&PyCell_Type); - OptimizedUnicode = (PyObject*)&PyCell_Type; - PyDict_SetItemString(dict, "OptimizedUnicode", OptimizedUnicode); + pysqlite_OptimizedUnicode = (PyObject*)&PyCell_Type; + PyDict_SetItemString(dict, "OptimizedUnicode", pysqlite_OptimizedUnicode); /* Set integer constants */ for (i = 0; _int_constants[i].constant_name != 0; i++) { diff --git a/Modules/_sqlite/module.h b/Modules/_sqlite/module.h index e514bd1..ada6b4c 100644 --- a/Modules/_sqlite/module.h +++ b/Modules/_sqlite/module.h @@ -25,20 +25,20 @@ #define PYSQLITE_MODULE_H #include "Python.h" -#define PYSQLITE_VERSION "2.3.2" - -extern PyObject* Error; -extern PyObject* Warning; -extern PyObject* InterfaceError; -extern PyObject* DatabaseError; -extern PyObject* InternalError; -extern PyObject* OperationalError; -extern PyObject* ProgrammingError; -extern PyObject* IntegrityError; -extern PyObject* DataError; -extern PyObject* NotSupportedError; - -extern PyObject* OptimizedUnicode; +#define PYSQLITE_VERSION "2.3.3" + +extern PyObject* pysqlite_Error; +extern PyObject* pysqlite_Warning; +extern PyObject* pysqlite_InterfaceError; +extern PyObject* pysqlite_DatabaseError; +extern PyObject* pysqlite_InternalError; +extern PyObject* pysqlite_OperationalError; +extern PyObject* pysqlite_ProgrammingError; +extern PyObject* pysqlite_IntegrityError; +extern PyObject* pysqlite_DataError; +extern PyObject* pysqlite_NotSupportedError; + +extern PyObject* pysqlite_OptimizedUnicode; /* the functions time.time() and time.sleep() */ extern PyObject* time_time; diff --git a/Modules/_sqlite/prepare_protocol.c b/Modules/_sqlite/prepare_protocol.c index 26b663b..a8ca518 100644 --- a/Modules/_sqlite/prepare_protocol.c +++ b/Modules/_sqlite/prepare_protocol.c @@ -23,23 +23,23 @@ #include "prepare_protocol.h" -int prepare_protocol_init(SQLitePrepareProtocol* self, PyObject* args, PyObject* kwargs) +int pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol* self, PyObject* args, PyObject* kwargs) { return 0; } -void prepare_protocol_dealloc(SQLitePrepareProtocol* self) +void pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol* self) { self->ob_type->tp_free((PyObject*)self); } -PyTypeObject SQLitePrepareProtocolType= { +PyTypeObject pysqlite_PrepareProtocolType= { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ MODULE_NAME ".PrepareProtocol", /* tp_name */ - sizeof(SQLitePrepareProtocol), /* tp_basicsize */ + sizeof(pysqlite_PrepareProtocol), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)prepare_protocol_dealloc, /* tp_dealloc */ + (destructor)pysqlite_prepare_protocol_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ @@ -70,15 +70,15 @@ PyTypeObject SQLitePrepareProtocolType= { 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)prepare_protocol_init, /* tp_init */ + (initproc)pysqlite_prepare_protocol_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0 /* tp_free */ }; -extern int prepare_protocol_setup_types(void) +extern int pysqlite_prepare_protocol_setup_types(void) { - SQLitePrepareProtocolType.tp_new = PyType_GenericNew; - SQLitePrepareProtocolType.ob_type= &PyType_Type; - return PyType_Ready(&SQLitePrepareProtocolType); + pysqlite_PrepareProtocolType.tp_new = PyType_GenericNew; + pysqlite_PrepareProtocolType.ob_type= &PyType_Type; + return PyType_Ready(&pysqlite_PrepareProtocolType); } diff --git a/Modules/_sqlite/prepare_protocol.h b/Modules/_sqlite/prepare_protocol.h index 2fc4f61..4c1e4f3 100644 --- a/Modules/_sqlite/prepare_protocol.h +++ b/Modules/_sqlite/prepare_protocol.h @@ -28,14 +28,14 @@ typedef struct { PyObject_HEAD -} SQLitePrepareProtocol; +} pysqlite_PrepareProtocol; -extern PyTypeObject SQLitePrepareProtocolType; +extern PyTypeObject pysqlite_PrepareProtocolType; -int prepare_protocol_init(SQLitePrepareProtocol* self, PyObject* args, PyObject* kwargs); -void prepare_protocol_dealloc(SQLitePrepareProtocol* self); +int pysqlite_prepare_protocol_init(pysqlite_PrepareProtocol* self, PyObject* args, PyObject* kwargs); +void pysqlite_prepare_protocol_dealloc(pysqlite_PrepareProtocol* self); -int prepare_protocol_setup_types(void); +int pysqlite_prepare_protocol_setup_types(void); #define UNKNOWN (-1) #endif diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c index 80b6135..7cfcfc3 100644 --- a/Modules/_sqlite/row.c +++ b/Modules/_sqlite/row.c @@ -25,7 +25,7 @@ #include "cursor.h" #include "sqlitecompat.h" -void row_dealloc(Row* self) +void pysqlite_row_dealloc(pysqlite_Row* self) { Py_XDECREF(self->data); Py_XDECREF(self->description); @@ -33,10 +33,10 @@ void row_dealloc(Row* self) self->ob_type->tp_free((PyObject*)self); } -int row_init(Row* self, PyObject* args, PyObject* kwargs) +int pysqlite_row_init(pysqlite_Row* self, PyObject* args, PyObject* kwargs) { PyObject* data; - Cursor* cursor; + pysqlite_Cursor* cursor; self->data = 0; self->description = 0; @@ -45,7 +45,7 @@ int row_init(Row* self, PyObject* args, PyObject* kwargs) return -1; } - if (!PyObject_IsInstance((PyObject*)cursor, (PyObject*)&CursorType)) { + if (!PyObject_IsInstance((PyObject*)cursor, (PyObject*)&pysqlite_CursorType)) { PyErr_SetString(PyExc_TypeError, "instance of cursor required for first argument"); return -1; } @@ -64,7 +64,7 @@ int row_init(Row* self, PyObject* args, PyObject* kwargs) return 0; } -PyObject* row_subscript(Row* self, PyObject* idx) +PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx) { long _idx; char* key; @@ -133,32 +133,63 @@ PyObject* row_subscript(Row* self, PyObject* idx) } } -Py_ssize_t row_length(Row* self, PyObject* args, PyObject* kwargs) +Py_ssize_t pysqlite_row_length(pysqlite_Row* self, PyObject* args, PyObject* kwargs) { return PyTuple_GET_SIZE(self->data); } -static int row_print(Row* self, FILE *fp, int flags) +PyObject* pysqlite_row_keys(pysqlite_Row* self, PyObject* args, PyObject* kwargs) +{ + PyObject* list; + int nitems, i; + + list = PyList_New(0); + if (!list) { + return NULL; + } + nitems = PyTuple_Size(self->description); + + for (i = 0; i < nitems; i++) { + if (PyList_Append(list, PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0)) != 0) { + Py_DECREF(list); + return NULL; + } + } + + return list; +} + +static int pysqlite_row_print(pysqlite_Row* self, FILE *fp, int flags) { return (&PyTuple_Type)->tp_print(self->data, fp, flags); } +static PyObject* pysqlite_iter(pysqlite_Row* self) +{ + return PyObject_GetIter(self->data); +} -PyMappingMethods row_as_mapping = { - /* mp_length */ (lenfunc)row_length, - /* mp_subscript */ (binaryfunc)row_subscript, +PyMappingMethods pysqlite_row_as_mapping = { + /* mp_length */ (lenfunc)pysqlite_row_length, + /* mp_subscript */ (binaryfunc)pysqlite_row_subscript, /* mp_ass_subscript */ (objobjargproc)0, }; +static PyMethodDef pysqlite_row_methods[] = { + {"keys", (PyCFunction)pysqlite_row_keys, METH_NOARGS, + PyDoc_STR("Returns the keys of the row.")}, + {NULL, NULL} +}; + -PyTypeObject RowType = { +PyTypeObject pysqlite_RowType = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ MODULE_NAME ".Row", /* tp_name */ - sizeof(Row), /* tp_basicsize */ + sizeof(pysqlite_Row), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)row_dealloc, /* tp_dealloc */ - (printfunc)row_print, /* tp_print */ + (destructor)pysqlite_row_dealloc, /* tp_dealloc */ + (printfunc)pysqlite_row_print, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ @@ -174,13 +205,13 @@ PyTypeObject RowType = { 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 0, /* tp_doc */ - 0, /* tp_traverse */ + (traverseproc)0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ + (getiterfunc)pysqlite_iter, /* tp_iter */ 0, /* tp_iternext */ - 0, /* tp_methods */ + pysqlite_row_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ @@ -188,15 +219,15 @@ PyTypeObject RowType = { 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)row_init, /* tp_init */ + (initproc)pysqlite_row_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ 0 /* tp_free */ }; -extern int row_setup_types(void) +extern int pysqlite_row_setup_types(void) { - RowType.tp_new = PyType_GenericNew; - RowType.tp_as_mapping = &row_as_mapping; - return PyType_Ready(&RowType); + pysqlite_RowType.tp_new = PyType_GenericNew; + pysqlite_RowType.tp_as_mapping = &pysqlite_row_as_mapping; + return PyType_Ready(&pysqlite_RowType); } diff --git a/Modules/_sqlite/row.h b/Modules/_sqlite/row.h index c6e083c..b92225b 100644 --- a/Modules/_sqlite/row.h +++ b/Modules/_sqlite/row.h @@ -30,10 +30,10 @@ typedef struct _Row PyObject_HEAD PyObject* data; PyObject* description; -} Row; +} pysqlite_Row; -extern PyTypeObject RowType; +extern PyTypeObject pysqlite_RowType; -int row_setup_types(void); +int pysqlite_row_setup_types(void); #endif diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c index 55923e7..86d2178 100644 --- a/Modules/_sqlite/statement.c +++ b/Modules/_sqlite/statement.c @@ -29,7 +29,7 @@ #include "sqlitecompat.h" /* prototypes */ -int check_remaining_sql(const char* tail); +static int pysqlite_check_remaining_sql(const char* tail); typedef enum { LINECOMMENT_1, @@ -40,7 +40,7 @@ typedef enum { NORMAL } parse_remaining_sql_state; -int statement_create(Statement* self, Connection* connection, PyObject* sql) +int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* connection, PyObject* sql) { const char* tail; int rc; @@ -77,7 +77,7 @@ int statement_create(Statement* self, Connection* connection, PyObject* sql) self->db = connection->db; - if (rc == SQLITE_OK && check_remaining_sql(tail)) { + if (rc == SQLITE_OK && pysqlite_check_remaining_sql(tail)) { (void)sqlite3_finalize(self->st); self->st = NULL; rc = PYSQLITE_TOO_MUCH_SQL; @@ -86,7 +86,7 @@ int statement_create(Statement* self, Connection* connection, PyObject* sql) return rc; } -int statement_bind_parameter(Statement* self, int pos, PyObject* parameter) +int pysqlite_statement_bind_parameter(pysqlite_Statement* self, int pos, PyObject* parameter) { int rc = SQLITE_OK; long longval; @@ -133,7 +133,7 @@ int statement_bind_parameter(Statement* self, int pos, PyObject* parameter) return rc; } -void statement_bind_parameters(Statement* self, PyObject* parameters) +void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* parameters) { PyObject* current_param; PyObject* adapted; @@ -154,19 +154,19 @@ void statement_bind_parameters(Statement* self, PyObject* parameters) binding_name = sqlite3_bind_parameter_name(self->st, i); Py_END_ALLOW_THREADS if (!binding_name) { - PyErr_Format(ProgrammingError, "Binding %d has no name, but you supplied a dictionary (which has only names).", i); + PyErr_Format(pysqlite_ProgrammingError, "Binding %d has no name, but you supplied a dictionary (which has only names).", i); return; } binding_name++; /* skip first char (the colon) */ current_param = PyDict_GetItemString(parameters, binding_name); if (!current_param) { - PyErr_Format(ProgrammingError, "You did not supply a value for binding %d.", i); + PyErr_Format(pysqlite_ProgrammingError, "You did not supply a value for binding %d.", i); return; } Py_INCREF(current_param); - adapted = microprotocols_adapt(current_param, (PyObject*)&SQLitePrepareProtocolType, NULL); + adapted = microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, NULL); if (adapted) { Py_DECREF(current_param); } else { @@ -174,11 +174,11 @@ void statement_bind_parameters(Statement* self, PyObject* parameters) adapted = current_param; } - rc = statement_bind_parameter(self, i, adapted); + rc = pysqlite_statement_bind_parameter(self, i, adapted); Py_DECREF(adapted); if (rc != SQLITE_OK) { - PyErr_Format(InterfaceError, "Error binding parameter :%s - probably unsupported type.", binding_name); + PyErr_Format(pysqlite_InterfaceError, "Error binding parameter :%s - probably unsupported type.", binding_name); return; } } @@ -186,7 +186,7 @@ void statement_bind_parameters(Statement* self, PyObject* parameters) /* parameters passed as sequence */ num_params = PySequence_Length(parameters); if (num_params != num_params_needed) { - PyErr_Format(ProgrammingError, "Incorrect number of bindings supplied. The current statement uses %d, and there are %d supplied.", + PyErr_Format(pysqlite_ProgrammingError, "Incorrect number of bindings supplied. The current statement uses %d, and there are %d supplied.", num_params_needed, num_params); return; } @@ -195,7 +195,7 @@ void statement_bind_parameters(Statement* self, PyObject* parameters) if (!current_param) { return; } - adapted = microprotocols_adapt(current_param, (PyObject*)&SQLitePrepareProtocolType, NULL); + adapted = microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, NULL); if (adapted) { Py_DECREF(current_param); @@ -204,18 +204,18 @@ void statement_bind_parameters(Statement* self, PyObject* parameters) adapted = current_param; } - rc = statement_bind_parameter(self, i + 1, adapted); + rc = pysqlite_statement_bind_parameter(self, i + 1, adapted); Py_DECREF(adapted); if (rc != SQLITE_OK) { - PyErr_Format(InterfaceError, "Error binding parameter %d - probably unsupported type.", i); + PyErr_Format(pysqlite_InterfaceError, "Error binding parameter %d - probably unsupported type.", i); return; } } } } -int statement_recompile(Statement* self, PyObject* params) +int pysqlite_statement_recompile(pysqlite_Statement* self, PyObject* params) { const char* tail; int rc; @@ -250,7 +250,7 @@ int statement_recompile(Statement* self, PyObject* params) return rc; } -int statement_finalize(Statement* self) +int pysqlite_statement_finalize(pysqlite_Statement* self) { int rc; @@ -267,7 +267,7 @@ int statement_finalize(Statement* self) return rc; } -int statement_reset(Statement* self) +int pysqlite_statement_reset(pysqlite_Statement* self) { int rc; @@ -286,12 +286,12 @@ int statement_reset(Statement* self) return rc; } -void statement_mark_dirty(Statement* self) +void pysqlite_statement_mark_dirty(pysqlite_Statement* self) { self->in_use = 1; } -void statement_dealloc(Statement* self) +void pysqlite_statement_dealloc(pysqlite_Statement* self) { int rc; @@ -320,7 +320,7 @@ void statement_dealloc(Statement* self) * * Returns 1 if there is more left than should be. 0 if ok. */ -int check_remaining_sql(const char* tail) +static int pysqlite_check_remaining_sql(const char* tail) { const char* pos = tail; @@ -382,13 +382,13 @@ int check_remaining_sql(const char* tail) return 0; } -PyTypeObject StatementType = { +PyTypeObject pysqlite_StatementType = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ MODULE_NAME ".Statement", /* tp_name */ - sizeof(Statement), /* tp_basicsize */ + sizeof(pysqlite_Statement), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)statement_dealloc, /* tp_dealloc */ + (destructor)pysqlite_statement_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ @@ -408,7 +408,7 @@ PyTypeObject StatementType = { 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ - offsetof(Statement, in_weakreflist), /* tp_weaklistoffset */ + offsetof(pysqlite_Statement, in_weakreflist), /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ 0, /* tp_methods */ @@ -425,8 +425,8 @@ PyTypeObject StatementType = { 0 /* tp_free */ }; -extern int statement_setup_types(void) +extern int pysqlite_statement_setup_types(void) { - StatementType.tp_new = PyType_GenericNew; - return PyType_Ready(&StatementType); + pysqlite_StatementType.tp_new = PyType_GenericNew; + return PyType_Ready(&pysqlite_StatementType); } diff --git a/Modules/_sqlite/statement.h b/Modules/_sqlite/statement.h index 57ee36f..10b8823 100644 --- a/Modules/_sqlite/statement.h +++ b/Modules/_sqlite/statement.h @@ -39,21 +39,21 @@ typedef struct PyObject* sql; int in_use; PyObject* in_weakreflist; /* List of weak references */ -} Statement; +} pysqlite_Statement; -extern PyTypeObject StatementType; +extern PyTypeObject pysqlite_StatementType; -int statement_create(Statement* self, Connection* connection, PyObject* sql); -void statement_dealloc(Statement* self); +int pysqlite_statement_create(pysqlite_Statement* self, pysqlite_Connection* connection, PyObject* sql); +void pysqlite_statement_dealloc(pysqlite_Statement* self); -int statement_bind_parameter(Statement* self, int pos, PyObject* parameter); -void statement_bind_parameters(Statement* self, PyObject* parameters); +int pysqlite_statement_bind_parameter(pysqlite_Statement* self, int pos, PyObject* parameter); +void pysqlite_statement_bind_parameters(pysqlite_Statement* self, PyObject* parameters); -int statement_recompile(Statement* self, PyObject* parameters); -int statement_finalize(Statement* self); -int statement_reset(Statement* self); -void statement_mark_dirty(Statement* self); +int pysqlite_statement_recompile(pysqlite_Statement* self, PyObject* parameters); +int pysqlite_statement_finalize(pysqlite_Statement* self); +int pysqlite_statement_reset(pysqlite_Statement* self); +void pysqlite_statement_mark_dirty(pysqlite_Statement* self); -int statement_setup_types(void); +int pysqlite_statement_setup_types(void); #endif diff --git a/Modules/_sqlite/util.c b/Modules/_sqlite/util.c index f5a7233..b70297b 100644 --- a/Modules/_sqlite/util.c +++ b/Modules/_sqlite/util.c @@ -24,8 +24,7 @@ #include "module.h" #include "connection.h" -int _sqlite_step_with_busyhandler(sqlite3_stmt* statement, Connection* connection -) +int _sqlite_step_with_busyhandler(sqlite3_stmt* statement, pysqlite_Connection* connection) { int rc; @@ -40,7 +39,7 @@ int _sqlite_step_with_busyhandler(sqlite3_stmt* statement, Connection* connectio * Checks the SQLite error code and sets the appropriate DB-API exception. * Returns the error code (0 means no error occurred). */ -int _seterror(sqlite3* db) +int _pysqlite_seterror(sqlite3* db) { int errorcode; @@ -53,7 +52,7 @@ int _seterror(sqlite3* db) break; case SQLITE_INTERNAL: case SQLITE_NOTFOUND: - PyErr_SetString(InternalError, sqlite3_errmsg(db)); + PyErr_SetString(pysqlite_InternalError, sqlite3_errmsg(db)); break; case SQLITE_NOMEM: (void)PyErr_NoMemory(); @@ -71,23 +70,23 @@ int _seterror(sqlite3* db) case SQLITE_PROTOCOL: case SQLITE_EMPTY: case SQLITE_SCHEMA: - PyErr_SetString(OperationalError, sqlite3_errmsg(db)); + PyErr_SetString(pysqlite_OperationalError, sqlite3_errmsg(db)); break; case SQLITE_CORRUPT: - PyErr_SetString(DatabaseError, sqlite3_errmsg(db)); + PyErr_SetString(pysqlite_DatabaseError, sqlite3_errmsg(db)); break; case SQLITE_TOOBIG: - PyErr_SetString(DataError, sqlite3_errmsg(db)); + PyErr_SetString(pysqlite_DataError, sqlite3_errmsg(db)); break; case SQLITE_CONSTRAINT: case SQLITE_MISMATCH: - PyErr_SetString(IntegrityError, sqlite3_errmsg(db)); + PyErr_SetString(pysqlite_IntegrityError, sqlite3_errmsg(db)); break; case SQLITE_MISUSE: - PyErr_SetString(ProgrammingError, sqlite3_errmsg(db)); + PyErr_SetString(pysqlite_ProgrammingError, sqlite3_errmsg(db)); break; default: - PyErr_SetString(DatabaseError, sqlite3_errmsg(db)); + PyErr_SetString(pysqlite_DatabaseError, sqlite3_errmsg(db)); break; } diff --git a/Modules/_sqlite/util.h b/Modules/_sqlite/util.h index 7ce3d40..969c5e5 100644 --- a/Modules/_sqlite/util.h +++ b/Modules/_sqlite/util.h @@ -28,11 +28,11 @@ #include "sqlite3.h" #include "connection.h" -int _sqlite_step_with_busyhandler(sqlite3_stmt* statement, Connection* connection); +int _sqlite_step_with_busyhandler(sqlite3_stmt* statement, pysqlite_Connection* connection); /** * Checks the SQLite error code and sets the appropriate DB-API exception. * Returns the error code (0 means no error occurred). */ -int _seterror(sqlite3* db); +int _pysqlite_seterror(sqlite3* db); #endif |