[Python-checkins] r53420 - in python/trunk: Lib/sqlite3/dbapi2.py Lib/sqlite3/test/factory.py Lib/sqlite3/test/regression.py Lib/sqlite3/test/types.py Modules/_sqlite/cache.c Modules/_sqlite/cache.h Modules/_sqlite/connection.c Modules/_sqlite/connection.h Modules/_sqlite/cursor.c Modules/_sqlite/cursor.h Modules/_sqlite/microprotocols.c Modules/_sqlite/microprotocols.h Modules/_sqlite/module.c Modules/_sqlite/module.h Modules/_sqlite/prepare_protocol.c Modules/_sqlite/prepare_protocol.h Modules/_sqlite/row.c Modules/_sqlite/row.h Modules/_sqlite/statement.c Modules/_sqlite/statement.h Modules/_sqlite/util.c Modules/_sqlite/util.h
gerhard.haering
python-checkins at python.org
Sun Jan 14 02:43:53 CET 2007
Author: gerhard.haering
Date: Sun Jan 14 02:43:50 2007
New Revision: 53420
Modified:
python/trunk/Lib/sqlite3/dbapi2.py
python/trunk/Lib/sqlite3/test/factory.py
python/trunk/Lib/sqlite3/test/regression.py
python/trunk/Lib/sqlite3/test/types.py
python/trunk/Modules/_sqlite/cache.c
python/trunk/Modules/_sqlite/cache.h
python/trunk/Modules/_sqlite/connection.c
python/trunk/Modules/_sqlite/connection.h
python/trunk/Modules/_sqlite/cursor.c
python/trunk/Modules/_sqlite/cursor.h
python/trunk/Modules/_sqlite/microprotocols.c
python/trunk/Modules/_sqlite/microprotocols.h
python/trunk/Modules/_sqlite/module.c
python/trunk/Modules/_sqlite/module.h
python/trunk/Modules/_sqlite/prepare_protocol.c
python/trunk/Modules/_sqlite/prepare_protocol.h
python/trunk/Modules/_sqlite/row.c
python/trunk/Modules/_sqlite/row.h
python/trunk/Modules/_sqlite/statement.c
python/trunk/Modules/_sqlite/statement.h
python/trunk/Modules/_sqlite/util.c
python/trunk/Modules/_sqlite/util.h
Log:
Merged changes from standalone version 2.3.3. This should probably all be
merged into the 2.5 maintenance branch:
- self->statement was not checked while fetching data, which could
lead to crashes if you used the pysqlite API in unusual ways.
Closing the cursor and continuing to fetch data was enough.
- Converters are stored in a converters dictionary. The converter name
is uppercased first. The old upper-casing algorithm was wrong and
was replaced by a simple call to the Python string's upper() method
instead.
-Applied patch by Glyph Lefkowitz that fixes the problem with
subsequent SQLITE_SCHEMA errors.
- Improvement to the row type: rows can now be iterated over and have a keys()
method. This improves compatibility with both tuple and dict a lot.
- A bugfix for the subsecond resolution in timestamps.
- Corrected the way the flags PARSE_DECLTYPES and PARSE_COLNAMES are
checked for. Now they work as documented.
- gcc on Linux sucks. It exports all symbols by default in shared
libraries, so if symbols are not unique it can lead to problems with
symbol lookup. pysqlite used to crash under Apache when mod_cache
was enabled because both modules had the symbol cache_init. I fixed
this by applying the prefix pysqlite_ almost everywhere. Sigh.
Modified: python/trunk/Lib/sqlite3/dbapi2.py
==============================================================================
--- python/trunk/Lib/sqlite3/dbapi2.py (original)
+++ python/trunk/Lib/sqlite3/dbapi2.py Sun Jan 14 02:43:50 2007
@@ -68,7 +68,7 @@
timepart_full = timepart.split(".")
hours, minutes, seconds = map(int, timepart_full[0].split(":"))
if len(timepart_full) == 2:
- microseconds = int(float("0." + timepart_full[1]) * 1000000)
+ microseconds = int(timepart_full[1])
else:
microseconds = 0
Modified: python/trunk/Lib/sqlite3/test/factory.py
==============================================================================
--- python/trunk/Lib/sqlite3/test/factory.py (original)
+++ python/trunk/Lib/sqlite3/test/factory.py Sun Jan 14 02:43:50 2007
@@ -91,7 +91,7 @@
list),
"row is not instance of list")
- def CheckSqliteRow(self):
+ def CheckSqliteRowIndex(self):
self.con.row_factory = sqlite.Row
row = self.con.execute("select 1 as a, 2 as b").fetchone()
self.failUnless(isinstance(row,
@@ -110,6 +110,27 @@
self.failUnless(col1 == 1, "by index: wrong result for column 0")
self.failUnless(col2 == 2, "by index: wrong result for column 1")
+ def CheckSqliteRowIter(self):
+ """Checks if the row object is iterable"""
+ self.con.row_factory = sqlite.Row
+ row = self.con.execute("select 1 as a, 2 as b").fetchone()
+ for col in row:
+ pass
+
+ def CheckSqliteRowAsTuple(self):
+ """Checks if the row object can be converted to a tuple"""
+ self.con.row_factory = sqlite.Row
+ row = self.con.execute("select 1 as a, 2 as b").fetchone()
+ t = tuple(row)
+
+ def CheckSqliteRowAsDict(self):
+ """Checks if the row object can be correctly converted to a dictionary"""
+ self.con.row_factory = sqlite.Row
+ row = self.con.execute("select 1 as a, 2 as b").fetchone()
+ d = dict(row)
+ self.failUnlessEqual(d["a"], row["a"])
+ self.failUnlessEqual(d["b"], row["b"])
+
def tearDown(self):
self.con.close()
Modified: python/trunk/Lib/sqlite3/test/regression.py
==============================================================================
--- python/trunk/Lib/sqlite3/test/regression.py (original)
+++ python/trunk/Lib/sqlite3/test/regression.py Sun Jan 14 02:43:50 2007
@@ -69,6 +69,16 @@
cur.execute('select 1 as "foo baz"')
self.failUnlessEqual(cur.description[0][0], "foo baz")
+ def CheckStatementAvailable(self):
+ # pysqlite up to 2.3.2 crashed on this, because the active statement handle was not checked
+ # before trying to fetch data from it. close() destroys the active statement ...
+ con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES)
+ cur = con.cursor()
+ cur.execute("select 4 union select 5")
+ cur.close()
+ cur.fetchone()
+ cur.fetchone()
+
def suite():
regression_suite = unittest.makeSuite(RegressionTests, "Check")
return unittest.TestSuite((regression_suite,))
Modified: python/trunk/Lib/sqlite3/test/types.py
==============================================================================
--- python/trunk/Lib/sqlite3/test/types.py (original)
+++ python/trunk/Lib/sqlite3/test/types.py Sun Jan 14 02:43:50 2007
@@ -106,6 +106,7 @@
# and implement two custom ones
sqlite.converters["BOOL"] = lambda x: bool(int(x))
sqlite.converters["FOO"] = DeclTypesTests.Foo
+ sqlite.converters["WRONG"] = lambda x: "WRONG"
def tearDown(self):
del sqlite.converters["FLOAT"]
@@ -117,7 +118,7 @@
def CheckString(self):
# default
self.cur.execute("insert into test(s) values (?)", ("foo",))
- self.cur.execute("select s from test")
+ self.cur.execute('select s as "s [WRONG]" from test')
row = self.cur.fetchone()
self.failUnlessEqual(row[0], "foo")
@@ -204,26 +205,32 @@
class ColNamesTests(unittest.TestCase):
def setUp(self):
- self.con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES|sqlite.PARSE_DECLTYPES)
+ self.con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES)
self.cur = self.con.cursor()
self.cur.execute("create table test(x foo)")
sqlite.converters["FOO"] = lambda x: "[%s]" % x
sqlite.converters["BAR"] = lambda x: "<%s>" % x
sqlite.converters["EXC"] = lambda x: 5/0
+ sqlite.converters["B1B1"] = lambda x: "MARKER"
def tearDown(self):
del sqlite.converters["FOO"]
del sqlite.converters["BAR"]
del sqlite.converters["EXC"]
+ del sqlite.converters["B1B1"]
self.cur.close()
self.con.close()
- def CheckDeclType(self):
+ def CheckDeclTypeNotUsed(self):
+ """
+ Assures that the declared type is not used when PARSE_DECLTYPES
+ is not set.
+ """
self.cur.execute("insert into test(x) values (?)", ("xxx",))
self.cur.execute("select x from test")
val = self.cur.fetchone()[0]
- self.failUnlessEqual(val, "[xxx]")
+ self.failUnlessEqual(val, "xxx")
def CheckNone(self):
self.cur.execute("insert into test(x) values (?)", (None,))
@@ -241,6 +248,11 @@
# whitespace should be stripped.
self.failUnlessEqual(self.cur.description[0][0], "x")
+ def CheckCaseInConverterName(self):
+ self.cur.execute("""select 'other' as "x [b1b1]\"""")
+ val = self.cur.fetchone()[0]
+ self.failUnlessEqual(val, "MARKER")
+
def CheckCursorDescriptionNoRow(self):
"""
cursor.description should at least provide the column name(s), even if
@@ -334,6 +346,13 @@
ts2 = self.cur.fetchone()[0]
self.failUnlessEqual(ts, ts2)
+ def CheckDateTimeSubSecondsFloatingPoint(self):
+ ts = sqlite.Timestamp(2004, 2, 14, 7, 15, 0, 510241)
+ self.cur.execute("insert into test(ts) values (?)", (ts,))
+ self.cur.execute("select ts from test")
+ ts2 = self.cur.fetchone()[0]
+ self.failUnlessEqual(ts, ts2)
+
def suite():
sqlite_type_suite = unittest.makeSuite(SqliteTypeTests, "Check")
decltypes_type_suite = unittest.makeSuite(DeclTypesTests, "Check")
Modified: python/trunk/Modules/_sqlite/cache.c
==============================================================================
--- python/trunk/Modules/_sqlite/cache.c (original)
+++ python/trunk/Modules/_sqlite/cache.c Sun Jan 14 02:43:50 2007
@@ -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 @@
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 @@
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 @@
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 @@
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 @@
return NULL;
}
- node = new_node(key, data);
+ node = pysqlite_new_node(key, data);
if (!node) {
return NULL;
}
@@ -211,9 +211,9 @@
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 @@
}
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 @@
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 @@
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;
}
Modified: python/trunk/Modules/_sqlite/cache.h
==============================================================================
--- python/trunk/Modules/_sqlite/cache.h (original)
+++ python/trunk/Modules/_sqlite/cache.h Sun Jan 14 02:43:50 2007
@@ -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 @@
/* 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
Modified: python/trunk/Modules/_sqlite/connection.c
==============================================================================
--- python/trunk/Modules/_sqlite/connection.c (original)
+++ python/trunk/Modules/_sqlite/connection.c Sun Jan 14 02:43:50 2007
@@ -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 @@
#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 @@
Py_END_ALLOW_THREADS
if (rc != SQLITE_OK) {
- _seterror(self->db);
+ _pysqlite_seterror(self->db);
return -1;
}
@@ -95,10 +95,10 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
*
* 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 @@
Py_END_ALLOW_THREADS
if (rc != SQLITE_OK) {
- _seterror(self->db);
+ _pysqlite_seterror(self->db);
goto error;
}
@@ -300,7 +300,7 @@
if (rc == SQLITE_DONE) {
self->inTransaction = 1;
} else {
- _seterror(self->db);
+ _pysqlite_seterror(self->db);
}
Py_BEGIN_ALLOW_THREADS
@@ -308,7 +308,7 @@
Py_END_ALLOW_THREADS
if (rc != SQLITE_OK && !PyErr_Occurred()) {
- _seterror(self->db);
+ _pysqlite_seterror(self->db);
}
error:
@@ -320,13 +320,13 @@
}
}
-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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
}
}
-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 @@
}
}
-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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
_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 @@
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 @@
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 @@
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_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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* ------------------------- 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 @@
}
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 @@
}
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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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);
}
Modified: python/trunk/Modules/_sqlite/connection.h
==============================================================================
--- python/trunk/Modules/_sqlite/connection.h (original)
+++ python/trunk/Modules/_sqlite/connection.h Sun Jan 14 02:43:50 2007
@@ -66,7 +66,7 @@
/* 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 @@
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
Modified: python/trunk/Modules/_sqlite/cursor.c
==============================================================================
--- python/trunk/Modules/_sqlite/cursor.c (original)
+++ python/trunk/Modules/_sqlite/cursor.c Sun Jan 14 02:43:50 2007
@@ -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 @@
}
}
-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 @@
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 @@
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 @@
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 @@
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 @@
break;
}
- converter = _get_converter(key);
+ converter = _pysqlite_get_converter(key);
Py_DECREF(key);
break;
}
@@ -198,7 +198,7 @@
}
}
- 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 @@
}
}
- converter = _get_converter(py_decltype);
+ converter = _pysqlite_get_converter(py_decltype);
Py_DECREF(py_decltype);
}
}
@@ -234,7 +234,7 @@
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* 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 @@
* 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 @@
} 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 @@
}
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 @@
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* 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 @@
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 @@
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 @@
/* 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 @@
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 @@
}
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 @@
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 @@
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 @@
PyErr_Clear();
}
}
- _seterror(self->connection->db);
+ _pysqlite_seterror(self->connection->db);
goto error;
}
}
@@ -649,7 +659,7 @@
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 @@
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 @@
}
if (multiple) {
- rc = statement_reset(self->statement);
+ rc = pysqlite_statement_reset(self->statement);
}
Py_XDECREF(parameters);
}
@@ -717,17 +727,17 @@
}
}
-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 @@
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 @@
}
/* commit first */
- result = connection_commit(self->connection, NULL);
+ result = pysqlite_connection_commit(self->connection, NULL);
if (!result) {
goto error;
}
@@ -778,7 +788,7 @@
&statement,
&script_cstr);
if (rc != SQLITE_OK) {
- _seterror(self->connection->db);
+ _pysqlite_seterror(self->connection->db);
goto error;
}
@@ -790,13 +800,13 @@
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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
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_fetchall(Cursor* self, PyObject* args)
+PyObject* pysqlite_cursor_fetchall(pysqlite_Cursor* self, PyObject* args)
{
PyObject* row;
PyObject* list;
@@ -933,7 +945,7 @@
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* 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 @@
}
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 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 @@
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 @@
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);
}
Modified: python/trunk/Modules/_sqlite/cursor.h
==============================================================================
--- python/trunk/Modules/_sqlite/cursor.h (original)
+++ python/trunk/Modules/_sqlite/cursor.h Sun Jan 14 02:43:50 2007
@@ -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
Modified: python/trunk/Modules/_sqlite/microprotocols.c
==============================================================================
--- python/trunk/Modules/_sqlite/microprotocols.c (original)
+++ python/trunk/Modules/_sqlite/microprotocols.c Sun Jan 14 02:43:50 2007
@@ -57,7 +57,7 @@
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 @@
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 @@
}
/* 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);
Modified: python/trunk/Modules/_sqlite/microprotocols.h
==============================================================================
--- python/trunk/Modules/_sqlite/microprotocols.h (original)
+++ python/trunk/Modules/_sqlite/microprotocols.h Sun Jan 14 02:43:50 2007
@@ -52,7 +52,7 @@
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."
Modified: python/trunk/Modules/_sqlite/module.c
==============================================================================
--- python/trunk/Modules/_sqlite/module.c (original)
+++ python/trunk/Modules/_sqlite/module.c Sun Jan 14 02:43:50 2007
@@ -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 @@
}
if (factory == NULL) {
- factory = (PyObject*)&ConnectionType;
+ factory = (PyObject*)&pysqlite_ConnectionType;
}
result = PyObject_Call(factory, args, kwargs);
@@ -115,7 +115,7 @@
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 @@
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_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 @@
return Py_None;
}
-void converters_init(PyObject* dict)
+static void converters_init(PyObject* dict)
{
converters = PyDict_New();
if (!converters) {
@@ -265,28 +258,28 @@
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 @@
/*** 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++) {
Modified: python/trunk/Modules/_sqlite/module.h
==============================================================================
--- python/trunk/Modules/_sqlite/module.h (original)
+++ python/trunk/Modules/_sqlite/module.h Sun Jan 14 02:43:50 2007
@@ -25,20 +25,20 @@
#define PYSQLITE_MODULE_H
#include "Python.h"
-#define PYSQLITE_VERSION "2.3.2"
+#define PYSQLITE_VERSION "2.3.3"
-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* 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* OptimizedUnicode;
+extern PyObject* pysqlite_OptimizedUnicode;
/* the functions time.time() and time.sleep() */
extern PyObject* time_time;
Modified: python/trunk/Modules/_sqlite/prepare_protocol.c
==============================================================================
--- python/trunk/Modules/_sqlite/prepare_protocol.c (original)
+++ python/trunk/Modules/_sqlite/prepare_protocol.c Sun Jan 14 02:43:50 2007
@@ -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 @@
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);
}
Modified: python/trunk/Modules/_sqlite/prepare_protocol.h
==============================================================================
--- python/trunk/Modules/_sqlite/prepare_protocol.h (original)
+++ python/trunk/Modules/_sqlite/prepare_protocol.h Sun Jan 14 02:43:50 2007
@@ -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
Modified: python/trunk/Modules/_sqlite/row.c
==============================================================================
--- python/trunk/Modules/_sqlite/row.c (original)
+++ python/trunk/Modules/_sqlite/row.c Sun Jan 14 02:43:50 2007
@@ -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 @@
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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
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);
}
Modified: python/trunk/Modules/_sqlite/row.h
==============================================================================
--- python/trunk/Modules/_sqlite/row.h (original)
+++ python/trunk/Modules/_sqlite/row.h Sun Jan 14 02:43:50 2007
@@ -30,10 +30,10 @@
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
Modified: python/trunk/Modules/_sqlite/statement.c
==============================================================================
--- python/trunk/Modules/_sqlite/statement.c (original)
+++ python/trunk/Modules/_sqlite/statement.c Sun Jan 14 02:43:50 2007
@@ -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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
return rc;
}
-int statement_finalize(Statement* self)
+int pysqlite_statement_finalize(pysqlite_Statement* self)
{
int rc;
@@ -267,7 +267,7 @@
return rc;
}
-int statement_reset(Statement* self)
+int pysqlite_statement_reset(pysqlite_Statement* self)
{
int rc;
@@ -286,12 +286,12 @@
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 @@
*
* 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 @@
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 @@
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 @@
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);
}
Modified: python/trunk/Modules/_sqlite/statement.h
==============================================================================
--- python/trunk/Modules/_sqlite/statement.h (original)
+++ python/trunk/Modules/_sqlite/statement.h Sun Jan 14 02:43:50 2007
@@ -39,21 +39,21 @@
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
Modified: python/trunk/Modules/_sqlite/util.c
==============================================================================
--- python/trunk/Modules/_sqlite/util.c (original)
+++ python/trunk/Modules/_sqlite/util.c Sun Jan 14 02:43:50 2007
@@ -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 @@
* 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 @@
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 @@
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;
}
Modified: python/trunk/Modules/_sqlite/util.h
==============================================================================
--- python/trunk/Modules/_sqlite/util.h (original)
+++ python/trunk/Modules/_sqlite/util.h Sun Jan 14 02:43:50 2007
@@ -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
More information about the Python-checkins
mailing list