BUG21536507: Fix raising warnings as exceptions

We fix a few issues around raising_on_warnings is set to True. When
using CExtension, no errors were thrown as exceptions when the
executed statement produced an error. Also, when statement produces a
result, it was not possible to reuse the cursor.

A test case has been added for BUG#21536507
(cherry picked from commit 6a2b67d)

Author: Geert Vanderkelen

lib/mysql/connector/connection.py

@@ -810,8 +810,8 @@ def cursor(self, buffered=None, raw=None, prepared=None, cursor_class=None,
                     "Cursor class needs be to subclass of cursor.CursorBase")
             return (cursor_class)(self)
 
-        buffered = buffered or self._buffered
-        raw = raw or self._raw
+        buffered = buffered if buffered is not None else self._buffered
+        raw = raw if raw is not None else self._raw
 
         cursor_type = 0
         if buffered is True:

lib/mysql/connector/cursor.py

@@ -396,8 +396,10 @@ def _handle_noresultset(self, res):
             raise errors.ProgrammingError(
                 "Failed handling non-resultset; {0}".format(err))
 
-        if self._connection.get_warnings is True and self._warning_count:
-            self._warnings = self._fetch_warnings()
+        self._handle_warnings()
+        if self._connection.raise_on_warnings is True and self._warnings:
+            raise errors.get_mysql_exception(
+                self._warnings[0][1], self._warnings[0][2])
 
     def _handle_resultset(self):
         """Handles result set
@@ -746,29 +748,33 @@ def _fetch_warnings(self):
         """
         res = []
         try:
-            cur = self._connection.cursor()
+            cur = self._connection.cursor(raw=False)
             cur.execute("SHOW WARNINGS")
             res = cur.fetchall()
             cur.close()
         except Exception as err:
             raise errors.InterfaceError(
                 "Failed getting warnings; %s" % err)
 
-        if self._connection.raise_on_warnings is True:
-            raise errors.get_mysql_exception(res[0][1], res[0][2])
-        else:
-            if len(res):
-                return res
+        if len(res):
+            return res
 
         return None
 
+    def _handle_warnings(self):
+        """Handle possible warnings after all results are consumed"""
+        if self._connection.get_warnings is True and self._warning_count:
+            self._warnings = self._fetch_warnings()
+
     def _handle_eof(self, eof):
         """Handle EOF packet"""
         self._connection.unread_result = False
         self._nextrow = (None, None)
         self._warning_count = eof['warning_count']
-        if self._connection.get_warnings is True and eof['warning_count']:
-            self._warnings = self._fetch_warnings()
+        self._handle_warnings()
+        if self._connection.raise_on_warnings is True and self._warnings:
+            raise errors.get_mysql_exception(
+                self._warnings[0][1], self._warnings[0][2])
 
     def _fetch_row(self):
         """Returns the next row in the result set

lib/mysql/connector/cursor_cext.py

@@ -130,6 +130,7 @@ def _fetch_warnings(self):
             self._cnx.consume_results()
             _ = self._cnx.cmd_query("SHOW WARNINGS")
             warnings = self._cnx.get_rows()
+            self._cnx.consume_results()
         except MySQLInterfaceError as exc:
             raise errors.get_mysql_exception(msg=exc.msg, errno=exc.errno,
                                              sqlstate=exc.sqlstate)
@@ -158,6 +159,9 @@ def _handle_result(self, result):
             self._warning_count = result['warning_count']
             self._affected_rows = result['affected_rows']
             self._rowcount = -1
+            self._handle_warnings()
+            if self._cnx.raise_on_warnings is True and self._warnings:
+                raise errors.get_mysql_exception(*self._warnings[0][1:3])
 
     def _handle_resultset(self):
         """Handle a result set"""

tests/__init__.py

@@ -36,6 +36,7 @@
 import shutil
 import subprocess
 import errno
+import traceback
 from imp import load_source
 from functools import wraps
 from pkgutil import walk_packages
@@ -437,6 +438,7 @@ def wrapper(self, *args, **kwargs):
                 try:
                     func(self, *args, **kwargs)
                 except Exception as exc:
+                    traceback.print_exc(file=sys.stdout)
                     raise exc
                 finally:
                     try:
@@ -613,7 +615,7 @@ def connc_connect_args(self, recache=False):
         :return: Dictionary containing connection arguments.
         :rtype: dict
         """
-        self.config = get_mysql_config()
+        self.config = get_mysql_config().copy()
 
         if not self.hasattr('connc_kwargs') or recache is True:
             connect_args = [

tests/test_abstracts.py

@@ -162,7 +162,6 @@ def test_cmd_init_db(self):
 
     @foreach_cnx()
     def test_reset_session(self):
-        config = tests.get_mysql_config()
         exp = [True, u'STRICT_ALL_TABLES', u'-09:00', 33]
         self.cnx.autocommit = exp[0]
         self.cnx.sql_mode = exp[1]
@@ -252,7 +251,6 @@ def test_cmd_process_kill(self):
         pid = other_cnx.connection_id
 
         self.cnx.cmd_process_kill(pid)
-
         self.assertFalse(other_cnx.is_connected())
 
     @foreach_cnx()

tests/test_bugs.py

@@ -1889,7 +1889,7 @@ def test_get_connection(self):
         config = tests.get_mysql_config().copy()
         config['connection_timeout'] = 2
         cnxpool = pooling.MySQLConnectionPool(
-            pool_name='test', pool_size=1, **tests.get_mysql_config())
+            pool_name='test', pool_size=1, **config)
 
         pcnx = cnxpool.get_connection()
         self.assertTrue(isinstance(pcnx, pooling.PooledMySQLConnection))
@@ -3603,23 +3603,28 @@ class BugOra20653441(tests.MySQLConnectorTests):
 
     def setUp(self):
         self.table_name = 'Bug20653441'
+        self._setup()
 
     def _setup(self):
-        self.cnx.cmd_query("DROP TABLE IF EXISTS {0}".format(self.table_name))
+        config = tests.get_mysql_config()
+        cnx = connection.MySQLConnection(**config)
+        cnx.cmd_query("DROP TABLE IF EXISTS {0}".format(self.table_name))
         table = (
             "CREATE TABLE {table} ("
             " id INT UNSIGNED NOT NULL AUTO_INCREMENT,"
             " c1 VARCHAR(255) DEFAULT '{default}',"
             " PRIMARY KEY (id)"
             ")"
         ).format(table=self.table_name, default='a' * 255)
-        self.cnx.cmd_query(table)
+        cnx.cmd_query(table)
 
         stmt = "INSERT INTO {table} (id) VALUES {values}".format(
             table=self.table_name,
             values=','.join(['(NULL)'] * 1024)
         )
-        self.cnx.cmd_query(stmt)
+        cnx.cmd_query(stmt)
+        cnx.commit()
+        cnx.close()
 
     def tearDown(self):
         try:
@@ -3632,14 +3637,13 @@ def tearDown(self):
 
     @foreach_cnx()
     def test_kill_query(self):
-        self._setup()
 
         def kill(connection_id):
             """Kill query using separate connection"""
-            killer = connection.MySQLConnection(**tests.get_mysql_config())
+            killer_cnx = connection.MySQLConnection(**tests.get_mysql_config())
             time.sleep(1)
-            killer.cmd_query("KILL QUERY {0}".format(connection_id))
-            killer.close()
+            killer_cnx.cmd_query("KILL QUERY {0}".format(connection_id))
+            killer_cnx.close()
 
         def sleepy_select(cnx):
             """Execute a SELECT statement which takes a while to complete"""
@@ -3664,10 +3668,37 @@ def sleepy_select(cnx):
         worker.join()
         killer.join()
 
+        self.cnx.close()
+
         self.assertTrue(isinstance(self.cnx.test_error, errors.DatabaseError))
         self.assertEqual(str(self.cnx.test_error),
                          "1317 (70100): Query execution was interrupted")
-        self.cnx.close()
+
+
+class BugOra21536507(tests.MySQLConnectorTests):
+    """BUG#21536507:C/PYTHON BEHAVIOR NOT PROPER WHEN RAISE_ON_WARNINGS=TRUE
+    """
+    @cnx_config(raw=True, get_warnings=True, raise_on_warnings=True)
+    @foreach_cnx()
+    def test_with_raw(self):
+        cur = self.cnx.cursor()
+        drop_stmt = "DROP TABLE IF EXISTS unknown"
+        self.assertRaises(errors.DatabaseError, cur.execute, drop_stmt)
+        exp = [('Note', 1051, "Unknown table 'myconnpy.unknown'")]
+        self.assertEqual(exp, cur.fetchwarnings())
+
+        select_stmt = "SELECT 'a'+'b'"
+        cur.execute(select_stmt)
+        self.assertRaises(errors.DatabaseError, cur.fetchall)
+        exp = [
+            ('Warning', 1292, "Truncated incorrect DOUBLE value: 'a'"),
+            ('Warning', 1292, "Truncated incorrect DOUBLE value: 'b'"),
+        ]
+        self.assertEqual(exp, cur.fetchwarnings())
+        try:
+            cur.close()
+        except errors.InternalError as exc:
+            self.fail("Closing cursor failed with: %s" % str(exc))
 
 
 class BugOra21420633(tests.MySQLConnectorTests):