From 6d21456137836b8acd551cf6a51999ad4ff10a91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gerhard=20H=C3=A4ring?= Date: Fri, 10 Aug 2007 18:15:11 +0000 Subject: Make the sqlite tests pass. --- Lib/sqlite3/test/factory.py | 18 +++++++++--------- Lib/sqlite3/test/types.py | 6 +++--- Lib/sqlite3/test/userfunctions.py | 4 ++-- Modules/_sqlite/connection.c | 6 ++---- Modules/_sqlite/cursor.c | 18 ++++++++---------- Modules/_sqlite/row.c | 4 ++-- Modules/_sqlite/statement.c | 3 ++- 7 files changed, 28 insertions(+), 31 deletions(-) diff --git a/Lib/sqlite3/test/factory.py b/Lib/sqlite3/test/factory.py index 61edc6c..f20848f 100644 --- a/Lib/sqlite3/test/factory.py +++ b/Lib/sqlite3/test/factory.py @@ -139,32 +139,32 @@ class TextFactoryTests(unittest.TestCase): self.con = sqlite.connect(":memory:") def CheckUnicode(self): - austria = str("Österreich", "latin1") + austria = "Österreich" row = self.con.execute("select ?", (austria,)).fetchone() self.failUnless(type(row[0]) == str, "type of row[0] must be unicode") def CheckString(self): - self.con.text_factory = str - austria = str("Österreich", "latin1") + self.con.text_factory = bytes + austria = "Österreich" row = self.con.execute("select ?", (austria,)).fetchone() - self.failUnless(type(row[0]) == str, "type of row[0] must be str") + self.failUnless(type(row[0]) == bytes, "type of row[0] must be bytes") self.failUnless(row[0] == austria.encode("utf-8"), "column must equal original data in UTF-8") def CheckCustom(self): self.con.text_factory = lambda x: str(x, "utf-8", "ignore") - austria = str("Österreich", "latin1") - row = self.con.execute("select ?", (austria.encode("latin1"),)).fetchone() + austria = "Österreich" + row = self.con.execute("select ?", (austria,)).fetchone() self.failUnless(type(row[0]) == str, "type of row[0] must be unicode") self.failUnless(row[0].endswith("reich"), "column must contain original data") def CheckOptimizedUnicode(self): self.con.text_factory = sqlite.OptimizedUnicode - austria = str("Österreich", "latin1") - germany = str("Deutchland") + austria = "Österreich" + germany = "Deutchland" a_row = self.con.execute("select ?", (austria,)).fetchone() d_row = self.con.execute("select ?", (germany,)).fetchone() self.failUnless(type(a_row[0]) == str, "type of non-ASCII row must be unicode") - self.failUnless(type(d_row[0]) == str, "type of ASCII-only row must be str") + self.failUnless(type(d_row[0]) == str8, "type of ASCII-only row must be str8") def tearDown(self): self.con.close() diff --git a/Lib/sqlite3/test/types.py b/Lib/sqlite3/test/types.py index 232a32c..20f0093 100644 --- a/Lib/sqlite3/test/types.py +++ b/Lib/sqlite3/test/types.py @@ -62,7 +62,7 @@ class SqliteTypeTests(unittest.TestCase): self.failUnlessEqual(row[0], val) def CheckBlob(self): - val = buffer("Guglhupf") + val = buffer(b"Guglhupf") self.cur.execute("insert into test(b) values (?)", (val,)) self.cur.execute("select b from test") row = self.cur.fetchone() @@ -203,7 +203,7 @@ class DeclTypesTests(unittest.TestCase): def CheckBlob(self): # default - val = buffer("Guglhupf") + val = buffer(b"Guglhupf") self.cur.execute("insert into test(bin) values (?)", (val,)) self.cur.execute("select bin from test") row = self.cur.fetchone() @@ -304,7 +304,7 @@ class BinaryConverterTests(unittest.TestCase): self.con.close() def CheckBinaryInputForConverter(self): - testdata = "abcdefg" * 10 + testdata = b"abcdefg" * 10 result = self.con.execute('select ? as "x [bin]"', (buffer(bz2.compress(testdata)),)).fetchone()[0] self.failUnlessEqual(testdata, result) diff --git a/Lib/sqlite3/test/userfunctions.py b/Lib/sqlite3/test/userfunctions.py index a2f2574..bc8e6d2 100644 --- a/Lib/sqlite3/test/userfunctions.py +++ b/Lib/sqlite3/test/userfunctions.py @@ -36,7 +36,7 @@ def func_returnfloat(): def func_returnnull(): return None def func_returnblob(): - return buffer("blob") + return buffer(b"blob") def func_raiseexception(): 5/0 @@ -197,7 +197,7 @@ class FunctionTests(unittest.TestCase): cur.execute("select returnblob()") val = cur.fetchone()[0] self.failUnlessEqual(type(val), buffer) - self.failUnlessEqual(val, buffer("blob")) + self.failUnlessEqual(val, buffer(b"blob")) def CheckFuncException(self): cur = self.con.cursor() diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c index add2e6f..41b94aa 100644 --- a/Modules/_sqlite/connection.c +++ b/Modules/_sqlite/connection.c @@ -435,10 +435,8 @@ void _pysqlite_set_result(sqlite3_context* context, PyObject* py_val) } else if (PyString_Check(py_val)) { sqlite3_result_text(context, PyString_AsString(py_val), -1, SQLITE_TRANSIENT); } else if (PyUnicode_Check(py_val)) { - stringval = PyUnicode_AsUTF8String(py_val); if (stringval) { - sqlite3_result_text(context, PyString_AsString(stringval), -1, SQLITE_TRANSIENT); - Py_DECREF(stringval); + sqlite3_result_text(context, PyUnicode_AsString(stringval), -1, SQLITE_TRANSIENT); } } else { /* TODO: raise error */ @@ -1094,7 +1092,7 @@ pysqlite_connection_create_collation(pysqlite_Connection* self, PyObject* args) goto finally; } - if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyString_Type, &name, &callable)) { + if (!PyArg_ParseTuple(args, "O!O:create_collation(name, callback)", &PyUnicode_Type, &name, &callable)) { goto finally; } diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c index 055e544..412e386 100644 --- a/Modules/_sqlite/cursor.c +++ b/Modules/_sqlite/cursor.c @@ -248,7 +248,7 @@ PyObject* _pysqlite_build_column_name(const char* colname) if ((*pos == '[') && (pos > colname) && (*(pos-1) == ' ')) { pos--; } - return PyString_FromStringAndSize(colname, pos - colname); + return PyUnicode_FromStringAndSize(colname, pos - colname); } } } @@ -372,8 +372,10 @@ PyObject* _pysqlite_fetch_one_row(pysqlite_Cursor* self) } } else if (self->connection->text_factory == (PyObject*)&PyString_Type) { converted = PyString_FromString(val_str); + } else if (self->connection->text_factory == (PyObject*)&PyBytes_Type) { + converted = PyBytes_FromStringAndSize(val_str, strlen(val_str)); } else { - converted = PyObject_CallFunction(self->connection->text_factory, "s", val_str); + converted = PyObject_CallFunction(self->connection->text_factory, "y", val_str); } } else { /* coltype == SQLITE_BLOB */ @@ -746,17 +748,13 @@ PyObject* pysqlite_cursor_executescript(pysqlite_Cursor* self, PyObject* args) return NULL; } - if (PyString_Check(script_obj)) { - script_cstr = PyString_AsString(script_obj); - } else if (PyUnicode_Check(script_obj)) { - script_str = PyUnicode_AsUTF8String(script_obj); - if (!script_str) { + if (PyUnicode_Check(script_obj)) { + script_cstr = PyUnicode_AsString(script_obj); + if (!script_cstr) { return NULL; } - - script_cstr = PyString_AsString(script_str); } else { - PyErr_SetString(PyExc_ValueError, "script argument must be unicode or string."); + PyErr_SetString(PyExc_ValueError, "script argument must be unicode."); return NULL; } diff --git a/Modules/_sqlite/row.c b/Modules/_sqlite/row.c index 6bd1887..b2f105a 100644 --- a/Modules/_sqlite/row.c +++ b/Modules/_sqlite/row.c @@ -86,8 +86,8 @@ PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx) item = PyTuple_GetItem(self->data, _idx); Py_XINCREF(item); return item; - } else if (PyString_Check(idx)) { - key = PyString_AsString(idx); + } else if (PyUnicode_Check(idx)) { + key = PyUnicode_AsString(idx); nitems = PyTuple_Size(self->description); diff --git a/Modules/_sqlite/statement.c b/Modules/_sqlite/statement.c index 5987b2a..b80b955 100644 --- a/Modules/_sqlite/statement.c +++ b/Modules/_sqlite/statement.c @@ -113,7 +113,8 @@ int pysqlite_statement_bind_parameter(pysqlite_Statement* self, int pos, PyObjec rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT); } else if PyUnicode_Check(parameter) { stringval = PyUnicode_AsUTF8String(parameter); - string = PyString_AsString(stringval); + string = PyBytes_AsString(stringval); + rc = sqlite3_bind_text(self->st, pos, string, -1, SQLITE_TRANSIENT); Py_DECREF(stringval); } else { -- cgit v0.12