BUG19500097: Fix regression caused by C Extension

peeyushgupta · peeyushgupta · commit 69ff2e6ee019 · 2014-11-24T17:41:46.000+05:30
BUG#19500097 resurfaced with the merging of C Extension with the
develop branch. We fix the regression and also fix the same problem
of 'binary' character set in C Extension.

The patch also fixes 'foreach_cnx' decorator in the tests, which was
consuming all the Exceptions not allowing any test case failure to
show up.
We also fix set_charset_collation() method which was not setting
the character set of the current connection properly.

Unit tests are updated.
diff --git a/lib/mysql/connector/abstracts.py b/lib/mysql/connector/abstracts.py
@@ -613,7 +613,7 @@ def python_charset(self):
         Returns a string.
         """
         encoding = CharacterSet.get_info(self._charset_id)[0]
-        if encoding == 'utf8mb4':
+        if encoding in ('utf8mb4', 'binary'):
             return 'utf8'
         else:
             return encoding
@@ -652,6 +652,14 @@ def set_charset_collation(self, charset=None, collation=None):
 
         self._execute_query("SET NAMES '{0}' COLLATE '{1}'".format(
             charset_name, collation_name))
+
+        try:
+            # Required for C Extension
+            self.set_character_set_name(charset_name)
+        except AttributeError:
+            # Not required for pure Python connection
+            pass
+
         if self.converter:
             self.converter.set_charset(charset_name)
 
diff --git a/lib/mysql/connector/connection_cext.py b/lib/mysql/connector/connection_cext.py
@@ -215,6 +215,11 @@ def ping(self, reconnect=False, attempts=1, delay=0):
             else:
                 raise errors.InterfaceError(errmsg)
 
+    def set_character_set_name(self, charset):
+        """Sets the default character set name for current connection.
+        """
+        self._cmysql.set_character_set(charset)
+
     def info_query(self, query):
         """Send a query which only returns 1 row"""
         self._cmysql.query(query)
diff --git a/src/mysql_capi.c b/src/mysql_capi.c
@@ -1178,6 +1178,10 @@ MySQL_escape_string(MySQL *self, PyObject *value)
 
     if (PyUnicode_Check(value))
     {
+        if (strcmp(charset, "binary") == 0)
+        {
+            charset = "utf8";
+        }
         from= PyUnicode_AsEncodedString(value, charset, NULL);
         if (!from)
         {
diff --git a/src/mysql_capi_conversion.c b/src/mysql_capi_conversion.c
@@ -736,7 +736,7 @@ mytopy_string(const char *data, const unsigned long length,
               const unsigned long flags, const char *charset,
               unsigned int use_unicode)
 {
-    if (!(flags & BINARY_FLAG) && use_unicode)
+    if (!(flags & BINARY_FLAG) && use_unicode && strcmp(charset, "binary") != 0)
     {
         return PyUnicode_Decode(data, length, charset, NULL);
     }
diff --git a/tests/__init__.py b/tests/__init__.py
@@ -430,18 +430,21 @@ def wrapper(self, *args, **kwargs):
                     self.cnx = cnx_class(**self.config)
                     self._testMethodName = "{0} (using {1})".format(
                         func.__name__, cnx_class.__name__)
-                    func(self, *args, **kwargs)
                 except:
                     if hasattr(self, 'cnx'):
                         # We will rollback/close later
                         pass
-
                 try:
-                    self.cnx.rollback()
-                    self.cnx.close()
-                except:
-                    # Might already be closed.
-                    pass
+                    func(self, *args, **kwargs)
+                except Exception as exc:
+                    raise exc
+                finally:
+                    try:
+                        self.cnx.rollback()
+                        self.cnx.close()
+                    except:
+                        # Might already be closed.
+                        pass
         return wrapper
     return _use_cnx
 
diff --git a/tests/test_bugs.py b/tests/test_bugs.py
@@ -3149,32 +3149,39 @@ class BugOra19500097(tests.MySQLConnectorTests):
     """
     def setUp(self):
         config = tests.get_mysql_config()
-        self.cnx = connection.MySQLConnection(**config)
-        self.cur = self.cnx.cursor()
+        cnx = connection.MySQLConnection(**config)
+        cur = cnx.cursor()
 
         self.tbl = 'Bug19500097'
-        self.cur.execute("DROP TABLE IF EXISTS {0}".format(self.tbl))
+        cur.execute("DROP TABLE IF EXISTS {0}".format(self.tbl))
 
         create = ("CREATE TABLE {0} (col1 VARCHAR(10), col2 INT) "
                   "DEFAULT CHARSET latin1".format(self.tbl))
-        self.cur.execute(create)
+        cur.execute(create)
+        cur.close()
+        cnx.close()
 
     def tearDown(self):
-        self.cur.execute("DROP TABLE IF EXISTS {0}".format(self.tbl))
-        self.cur.close()
-        self.cnx.close()
+        config = tests.get_mysql_config()
+        cnx = connection.MySQLConnection(**config)
+        cur = cnx.cursor()
+        cur.execute("DROP TABLE IF EXISTS {0}".format(self.tbl))
+        cur.close()
+        cnx.close()
 
+    @foreach_cnx()
     def test_binary_charset(self):
 
         sql = "INSERT INTO {0} VALUES(%s, %s)".format(self.tbl)
-        self.cur.execute(sql, ('foo', 1))
-        self.cur.execute(sql, ('ëëë', 2))
-        self.cur.execute(sql, (u'ááá', 5))
+        cur = self.cnx.cursor()
+        cur.execute(sql, ('foo', 1))
+        cur.execute(sql, ('ëëë', 2))
+        cur.execute(sql, (u'ááá', 5))
 
         self.cnx.set_charset_collation('binary')
-        self.cur.execute(sql, ('bar', 3))
-        self.cur.execute(sql, ('ëëë', 4))
-        self.cur.execute(sql, (u'ááá', 6))
+        cur.execute(sql, ('bar', 3))
+        cur.execute(sql, ('ëëë', 4))
+        cur.execute(sql, (u'ááá', 6))
 
         exp = [
             (bytearray(b'foo'), 1),
@@ -3184,9 +3191,8 @@ def test_binary_charset(self):
             (bytearray(b'\xc3\xab\xc3\xab\xc3\xab'), 4),
             (bytearray(b'\xc3\xa1\xc3\xa1\xc3\xa1'), 6)
         ]
-
-        self.cur.execute("SELECT * FROM {0}".format(self.tbl))
-        self.assertEqual(exp, self.cur.fetchall())
+        cur.execute("SELECT * FROM {0}".format(self.tbl))
+        self.assertEqual(exp, cur.fetchall())
 
 
 @unittest.skipIf(tests.MYSQL_VERSION < (5, 7, 3),

Original file line number	Diff line number	Diff line change
`@@ -1178,6 +1178,10 @@ MySQL_escape_string(MySQL self, PyObject value)`
`1178`	`1178`
`1179`	`1179`	`if (PyUnicode_Check(value))`
`1180`	`1180`	`{`
	`1181`	`+ if (strcmp(charset, "binary") == 0)`
	`1182`	`+ {`
	`1183`	`+ charset = "utf8";`
	`1184`	`+ }`
`1181`	`1185`	`from= PyUnicode_AsEncodedString(value, charset, NULL);`
`1182`	`1186`	`if (!from)`
`1183`	`1187`	`{`
Original file line number	Diff line number	Diff line change
`@@ -736,7 +736,7 @@ mytopy_string(const char *data, const unsigned long length,`
`736`	`736`	`const unsigned long flags, const char *charset,`
`737`	`737`	`unsigned int use_unicode)`
`738`	`738`	`{`
`739`		`- if (!(flags & BINARY_FLAG) && use_unicode)`
	`739`	`+ if (!(flags & BINARY_FLAG) && use_unicode && strcmp(charset, "binary") != 0)`
`740`	`740`	`{`
`741`	`741`	`return PyUnicode_Decode(data, length, charset, NULL);`
`742`	`742`	`}`