BUG29195610: Fix cursor.callproc() using namedtuple and dictionary cursors

This patch fixes the exception raised by namedtuple cursor due to the
invalid naming of columns generated. It also fixes the incorrect type
of result generated by dictionary cursors.

Tests were added for all cursor types.

Author: nmariz

lib/mysql/connector/cursor.py

@@ -774,10 +774,17 @@ def callproc(self, procname, args=()):
             can_consume_results = self._connection._consume_results
             for result in self._connection.cmd_query_iter(call):
                 self._connection._consume_results = False
-                if self._raw:
-                    tmp = MySQLCursorBufferedRaw(self._connection._get_self())
+                if isinstance(self, (MySQLCursorDict,
+                                     MySQLCursorBufferedDict)):
+                    cursor_class = MySQLCursorBufferedDict
+                elif isinstance(self, (MySQLCursorNamedTuple,
+                                       MySQLCursorBufferedNamedTuple)):
+                    cursor_class = MySQLCursorBufferedNamedTuple
+                elif self._raw:
+                    cursor_class = MySQLCursorBufferedRaw
                 else:
-                    tmp = MySQLCursorBuffered(self._connection._get_self())
+                    cursor_class = MySQLCursorBuffered
+                tmp = cursor_class(self._connection._get_self())
                 tmp._executed = "(a result of {0})".format(call)
                 tmp._handle_result(result)
                 if tmp._warnings is not None:
@@ -788,7 +795,12 @@ def callproc(self, procname, args=()):
             # pylint: enable=W0212
 
             if argnames:
-                select = "SELECT {0}".format(','.join(argtypes))
+                # Create names aliases to be compatible with namedtuples
+                args = [
+                    "{} AS {}".format(name, alias) for name, alias in
+                    zip(argtypes, [arg.lstrip("@_") for arg in argnames])
+                ]
+                select = "SELECT {}".format(",".join(args))
                 self.execute(select)
                 self._stored_results = results
                 return self.fetchone()

lib/mysql/connector/cursor_cext.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2014, 2020, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2014, 2020, Oracle and/or its affiliates.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License, version 2.0, as
@@ -450,10 +450,17 @@ def callproc(self, procname, args=()):
             while self._cnx.result_set_available:
                 result = self._cnx.fetch_eof_columns()
                 # pylint: disable=W0212
-                if self._raw:
-                    cur = CMySQLCursorBufferedRaw(self._cnx._get_self())
+                if isinstance(self, (CMySQLCursorDict,
+                                     CMySQLCursorBufferedDict)):
+                    cursor_class = CMySQLCursorBufferedDict
+                elif isinstance(self, (CMySQLCursorNamedTuple,
+                                       CMySQLCursorBufferedNamedTuple)):
+                    cursor_class = CMySQLCursorBufferedNamedTuple
+                elif self._raw:
+                    cursor_class = CMySQLCursorBufferedRaw
                 else:
-                    cur = CMySQLCursorBuffered(self._cnx._get_self())
+                    cursor_class = CMySQLCursorBuffered
+                cur = cursor_class(self._cnx._get_self())
                 cur._executed = "(a result of {0})".format(call)
                 cur._handle_result(result)
                 # pylint: enable=W0212
@@ -464,7 +471,12 @@ def callproc(self, procname, args=()):
 
             if argnames:
                 self.reset()
-                select = "SELECT {0}".format(','.join(argtypes))
+                # Create names aliases to be compatible with namedtuples
+                args = [
+                    "{} AS {}".format(name, alias) for name, alias in
+                    zip(argtypes, [arg.lstrip("@_") for arg in argnames])
+                ]
+                select = "SELECT {}".format(",".join(args))
                 self.execute(select)
 
                 return self.fetchone()

tests/test_bugs.py

@@ -45,6 +45,7 @@
 import os
 import gc
 import tempfile
+from collections import namedtuple
 from datetime import date, datetime, timedelta, time
 from threading import Thread
 import traceback
@@ -5703,3 +5704,80 @@ def test_cext_pool_support(self):
 
         exp = ('2',) if PY2 else (b'2',)
         self.assertNotEqual(exp, cnx.get_rows()[0][0])
+
+
+class BugOra29195610(tests.MySQLConnectorTests):
+    """BUG#29195610: CALLPROC() NOT SUPPORTED WITH NAMED TUPLE CURSOR AND FOR
+    DICT CURSOR IS IGNORED
+    """
+    def setUp(self):
+        config = tests.get_mysql_config()
+        with connection.MySQLConnection(**config) as cnx:
+            cnx.cmd_query("DROP TABLE IF EXISTS bug29195610")
+            cnx.cmd_query("DROP PROCEDURE IF EXISTS sp_bug29195610")
+            cnx.cmd_query("CREATE TABLE bug29195610 (id INT, name VARCHAR(5))")
+            cnx.cmd_query(
+                "INSERT INTO bug29195610 (id, name) VALUES (2020, 'Foo')"
+            )
+            cnx.cmd_query(
+                "CREATE PROCEDURE sp_bug29195610 (in_id INT) "
+                "SELECT id, name FROM bug29195610 WHERE id = in_id;"
+            )
+
+    def tearDown(self):
+        config = tests.get_mysql_config()
+        with connection.MySQLConnection(**config) as cnx:
+            cnx.cmd_query("DROP TABLE IF EXISTS bug29195610")
+            cnx.cmd_query("DROP PROCEDURE IF EXISTS sp_bug29195610")
+
+    @foreach_cnx()
+    def test_callproc_cursor_types(self):
+        named_tuple = namedtuple("Row", ["id", "name"])
+        cases = [
+            (
+                {},
+                [(2020, "Foo")]
+            ),
+            (
+                {"buffered": True},
+                [(2020, "Foo")]
+            ),
+            (
+                {"raw": True},
+                [(bytearray(b"2020"), bytearray(b"Foo"))]
+            ),
+            (
+                {"raw": True, "buffered": True},
+                [(bytearray(b"2020"), bytearray(b"Foo"))]
+            ),
+            (
+                {"raw": True, "buffered": True},
+                [(bytearray(b"2020"), bytearray(b"Foo"))]
+            ),
+            (
+                {"dictionary": True},
+                [{"id": 2020, "name": "Foo"}]
+            ),
+            (
+                {"dictionary": True, "buffered": True},
+                [{"id": 2020, "name": "Foo"}]
+            ),
+            (
+                {"named_tuple": True},
+                [named_tuple(2020, "Foo")]
+            ),
+            (
+                {"named_tuple": True, "buffered": True},
+                [named_tuple(2020, "Foo")]
+            )
+        ]
+
+        for cursor_type, exp in cases:
+            with self.cnx.cursor(**cursor_type) as cur:
+                cur.callproc("sp_bug29195610", (2020,))
+                for res in cur.stored_results():
+                    self.assertEqual(exp, res.fetchall())
+
+        with self.cnx.cursor(prepared=True) as cur:
+            self.assertRaises(errors.NotSupportedError,
+                              cur.callproc, 'sp_bug29195610', (2020,))