singlestoredb 0.4.0__py3-none-any.whl → 1.0.4__py3-none-any.whl

singlestoredb/mysql/tests/test_cursor.py

@@ -0,0 +1,141 @@
+# type: ignore
+import singlestoredb.mysql as sv
+import singlestoredb.mysql.cursors as cursors
+from singlestoredb.mysql.tests import base
+
+
+class CursorTest(base.PyMySQLTestCase):
+
+    def setUp(self):
+        super(CursorTest, self).setUp()
+
+        conn = self.connect()
+        self.safe_create_table(
+            conn,
+            'test',
+            'create table test (data varchar(10))',
+        )
+        cursor = conn.cursor()
+        cursor.execute(
+            'insert into test (data) values '
+            "('row1'), ('row2'), ('row3'), ('row4'), ('row5')",
+        )
+        cursor.close()
+        self.test_connection = sv.connect(**self.databases[0])
+        self.addCleanup(self.test_connection.close)
+
+    def test_cleanup_rows_unbuffered(self):
+        with self.connect(cursorclass=cursors.SSCursor) as conn:
+            with self.connect(cursorclass=cursors.SSCursor) as conn:
+                cursor = conn.cursor()
+
+                cursor.execute('select * from test as t1, test as t2')
+                for counter, row in enumerate(cursor):
+                    if counter > 10:
+                        break
+
+                del cursor
+
+                c2 = conn.cursor()
+
+                c2.execute('select 1')
+                self.assertEqual(c2.fetchone(), (1,))
+                self.assertIsNone(c2.fetchone())
+
+    def test_cleanup_rows_buffered(self):
+        with self.connect(cursorclass=cursors.Cursor) as conn:
+            cursor = conn.cursor()
+
+            cursor.execute('select * from test as t1, test as t2')
+            for counter, row in enumerate(cursor):
+                if counter > 10:
+                    break
+
+            del cursor
+
+            c2 = conn.cursor()
+            c2.execute('select 1')
+
+            self.assertEqual(c2.fetchone(), (1,))
+            self.assertIsNone(c2.fetchone())
+
+    def test_executemany(self):
+        with self.connect(cursorclass=cursors.Cursor) as conn:
+            cursor = conn.cursor()
+
+            m = cursors.RE_INSERT_VALUES.match(
+                'INSERT INTO TEST (ID, NAME) VALUES (%s, %s)',
+            )
+            self.assertIsNotNone(m, 'error parse %s')
+            self.assertEqual(
+                m.group(3), '', 'group 3 not blank, bug in RE_INSERT_VALUES?',
+            )
+
+            m = cursors.RE_INSERT_VALUES.match(
+                'INSERT INTO TEST (ID, NAME) VALUES (%(id)s, %(name)s)',
+            )
+            self.assertIsNotNone(m, 'error parse %(name)s')
+            self.assertEqual(
+                m.group(3), '', 'group 3 not blank, bug in RE_INSERT_VALUES?',
+            )
+
+            m = cursors.RE_INSERT_VALUES.match(
+                'INSERT INTO TEST (ID, NAME) VALUES (%(id_name)s, %(name)s)',
+            )
+            self.assertIsNotNone(m, 'error parse %(id_name)s')
+            self.assertEqual(
+                m.group(3), '', 'group 3 not blank, bug in RE_INSERT_VALUES?',
+            )
+
+            m = cursors.RE_INSERT_VALUES.match(
+                'INSERT INTO TEST (ID, NAME) VALUES (%(id_name)s, %(name)s) '
+                'ON duplicate update',
+            )
+            self.assertIsNotNone(m, 'error parse %(id_name)s')
+            self.assertEqual(
+                m.group(3),
+                ' ON duplicate update',
+                'group 3 not ON duplicate update, bug in RE_INSERT_VALUES?',
+            )
+
+            # https://github.com/PyMySQL/PyMySQL/pull/597
+            m = cursors.RE_INSERT_VALUES.match(
+                'INSERT INTO bloup(foo, bar)VALUES(%s, %s)',
+            )
+            assert m is not None
+
+            # cursor._executed must be "insert into test (data)
+            #                           values (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)"
+            # list args
+            data = range(10)
+            cursor.executemany('insert into test (data) values (%s)', data)
+            self.assertTrue(
+                cursor._executed.endswith(b',(7),(8),(9)'),
+                'execute many with %s not in one query',
+            )
+
+            # dict args
+            data_dict = [{'data': i} for i in range(10)]
+            cursor.executemany('insert into test (data) values (%(data)s)', data_dict)
+            self.assertTrue(
+                cursor._executed.endswith(b',(7),(8),(9)'),
+                'execute many with %(data)s not in one query',
+            )
+
+            # %% in column set
+            cursor.execute(
+                """\
+                CREATE TABLE percent_test (
+                    `A%` INTEGER,
+                    `B%` INTEGER)""",
+            )
+            try:
+                q = 'INSERT INTO percent_test (`A%%`, `B%%`) VALUES (%s, %s)'
+                self.assertIsNotNone(cursors.RE_INSERT_VALUES.match(q))
+                cursor.executemany(q, [(3, 4), (5, 6)])
+                self.assertTrue(
+                    cursor._executed.endswith(b'(3, 4),(5, 6)'),
+                    'executemany with %% not in one query',
+                )
+            finally:
+                cursor.execute('DROP TABLE IF EXISTS percent_test')

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_err.py

@@ -1,15 +1,16 @@
 # type: ignore
 import unittest
 
-from singlestoredb.clients.pymysqlsv import err
+from singlestoredb.mysql import err
 
 
 __all__ = ['TestRaiseException']
 
 
 class TestRaiseException(unittest.TestCase):
+
     def test_raise_mysql_exception(self):
         data = b'\xff\x15\x04#28000Access denied'
         with self.assertRaises(err.OperationalError) as cm:
             err.raise_mysql_exception(data)
-        self.assertEqual(cm.exception.args, (1045, 'Access denied'))
+        self.assertEqual(cm.exception.args, (1045, 'Access denied', None))

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_issues.py

@@ -1,21 +1,20 @@
 # type: ignore
 import datetime
-import sys
 import time
 import warnings
 
 import pytest
 
-import singlestoredb.clients.pymysqlsv as sv
-from singlestoredb.clients.pymysqlsv import cursors
-from singlestoredb.clients.pymysqlsv.tests import base
+import singlestoredb.mysql as sv
+from singlestoredb.mysql.tests import base
 
 __all__ = ['TestOldIssues', 'TestNewIssues', 'TestGitHubIssues']
 
 
 class TestOldIssues(base.PyMySQLTestCase):
+
     def test_issue_3(self):
-        """undefined methods datetime_or_None, date_or_None"""
+        """Undefined methods datetime_or_None, date_or_None."""
         conn = self.connect()
         c = conn.cursor()
         with warnings.catch_warnings():
@@ -43,7 +42,7 @@ class TestOldIssues(base.PyMySQLTestCase):
             c.execute('drop table issue3')
 
     def test_issue_4(self):
-        """can't retrieve TIMESTAMP fields"""
+        """Can't retrieve TIMESTAMP fields."""
         conn = self.connect()
         c = conn.cursor()
         with warnings.catch_warnings():
@@ -58,14 +57,14 @@ class TestOldIssues(base.PyMySQLTestCase):
             c.execute('drop table issue4')
 
     def test_issue_5(self):
-        """query on information_schema.tables fails"""
+        """Query on information_schema.tables fails."""
         con = self.connect()
         cur = con.cursor()
         cur.execute('select * from information_schema.tables')
 
     @pytest.mark.skip(reason='database is not created')
     def test_issue_6(self):
-        """exception: TypeError: ord() expected a character, but string of length 0 found"""
+        """TypeError: ord() expected a character, but string of length 0 found."""
         # ToDo: this test requires access to db 'mysql'.
         kwargs = self.databases[0].copy()
         kwargs['database'] = 'mysql'
@@ -75,7 +74,7 @@ class TestOldIssues(base.PyMySQLTestCase):
         conn.close()
 
     def test_issue_8(self):
-        """Primary Key and Index error when selecting data"""
+        """Primary Key and Index error when selecting data."""
         conn = self.connect()
         c = conn.cursor()
         with warnings.catch_warnings():
@@ -88,14 +87,14 @@ DEFAULT '0', `me` double DEFAULT NULL, `mo` double DEFAULT NULL, PRIMARY
 KEY (`station`,`dh`,`echeance`)) ENGINE=MyISAM DEFAULT CHARSET=latin1;""",
         )
         try:
-            self.assertEqual(0, c.execute('SELECT * FROM test'))
+            self.assertIn(c.execute('SELECT * FROM test'), [0, -1])
             c.execute('ALTER TABLE `test` ADD INDEX `idx_station` (`station`)')
-            self.assertEqual(0, c.execute('SELECT * FROM test'))
+            self.assertIn(c.execute('SELECT * FROM test'), [0, -1])
         finally:
             c.execute('drop table test')
 
     def test_issue_13(self):
-        """can't handle large result fields"""
+        """Can't handle large result fields."""
         conn = self.connect()
         cur = conn.cursor()
         with warnings.catch_warnings():
@@ -114,7 +113,7 @@ KEY (`station`,`dh`,`echeance`)) ENGINE=MyISAM DEFAULT CHARSET=latin1;""",
             cur.execute('drop table issue13')
 
     def test_issue_15(self):
-        """query should be expanded before perform character encoding"""
+        """Query should be expanded before perform character encoding."""
         conn = self.connect()
         c = conn.cursor()
         with warnings.catch_warnings():
@@ -129,7 +128,7 @@ KEY (`station`,`dh`,`echeance`)) ENGINE=MyISAM DEFAULT CHARSET=latin1;""",
             c.execute('drop table issue15')
 
     def test_issue_16(self):
-        """Patch for string and tuple escaping"""
+        """Patch for string and tuple escaping."""
         conn = self.connect()
         c = conn.cursor()
         with warnings.catch_warnings():
@@ -148,10 +147,11 @@ KEY (`station`,`dh`,`echeance`)) ENGINE=MyISAM DEFAULT CHARSET=latin1;""",
             c.execute('drop table issue16')
 
     @pytest.mark.skip(
-        'test_issue_17() requires a custom, legacy MySQL configuration and will not be run.',
+        'test_issue_17() requires a custom, legacy MySQL configuration '
+        'and will not be run.',
     )
     def test_issue_17(self):
-        """could not connect mysql use passwod"""
+        """Could not connect mysql use password."""
         conn = self.connect()
         host = self.databases[0]['host']
         db = self.databases[0]['database']
@@ -165,8 +165,10 @@ KEY (`station`,`dh`,`echeance`)) ENGINE=MyISAM DEFAULT CHARSET=latin1;""",
             c.execute('create table issue17 (x varchar(32) primary key)')
             c.execute("insert into issue17 (x) values ('hello, world!')")
             c.execute(
-                "grant all privileges on %s.issue17 to 'issue17user'@'%%' identified by '1234'"
-                % db,
+                (
+                    "grant all privileges on %s.issue17 to 'issue17user'@'%%' "
+                    "identified by '1234'"
+                ) % db,
             )
             conn.commit()
 
@@ -179,6 +181,7 @@ KEY (`station`,`dh`,`echeance`)) ENGINE=MyISAM DEFAULT CHARSET=latin1;""",
 
 
 class TestNewIssues(base.PyMySQLTestCase):
+
     def test_issue_34(self):
         try:
             sv.connect(host='localhost', port=1237, user='root')
@@ -287,8 +290,9 @@ class TestNewIssues(base.PyMySQLTestCase):
 
 
 class TestGitHubIssues(base.PyMySQLTestCase):
+
     def test_issue_66(self):
-        """'Connection' object has no attribute 'insert_id'"""
+        """'Connection' object has no attribute 'insert_id'."""
         conn = self.connect()
         c = conn.cursor()
         self.assertEqual(0, conn.insert_id())
@@ -306,9 +310,9 @@ class TestGitHubIssues(base.PyMySQLTestCase):
             c.execute('drop table issue66')
 
     def test_issue_79(self):
-        """Duplicate field overwrites the previous one in the result of DictCursor"""
-        conn = self.connect()
-        c = conn.cursor(sv.cursors.DictCursor)
+        """Duplicate field overwrites the previous one in the result of DictCursor."""
+        conn = self.connect(cursorclass=sv.cursors.DictCursor)
+        c = conn.cursor()
 
         with warnings.catch_warnings():
             warnings.filterwarnings('ignore')
@@ -333,7 +337,7 @@ class TestGitHubIssues(base.PyMySQLTestCase):
             c.execute('drop table b')
 
     def test_issue_95(self):
-        """Leftover trailing OK packet for "CALL my_sp" queries"""
+        """Leftover trailing OK packet for "CALL my_sp" queries."""
         conn = self.connect()
         cur = conn.cursor()
         with warnings.catch_warnings():
@@ -355,10 +359,14 @@ class TestGitHubIssues(base.PyMySQLTestCase):
                 cur.execute('DROP PROCEDURE IF EXISTS `foo`')
 
     def test_issue_114(self):
-        """autocommit is not set after reconnecting with ping()"""
+        """Autocommit is not set after reconnecting with ping()."""
         conn = sv.connect(charset='utf8', **self.databases[0])
         conn.autocommit(False)
         c = conn.cursor()
+
+        if type(c).__name__.startswith('SS'):
+            self.skipTest('Test hangs with unbuffered cursor')
+
         c.execute("""select @@autocommit;""")
         self.assertFalse(c.fetchone()[0])
         conn.close()
@@ -380,7 +388,7 @@ class TestGitHubIssues(base.PyMySQLTestCase):
         conn.close()
 
     def test_issue_175(self):
-        """The number of fields returned by server is read in wrong way"""
+        """The number of fields returned by server is read in wrong way."""
         conn = self.connect()
         cur = conn.cursor()
         for length in (200, 300):
@@ -410,7 +418,7 @@ class TestGitHubIssues(base.PyMySQLTestCase):
             'values (%(value_1)s, %(value_2)s)'
         )
         sql_select = 'select * from issue321 ' + \
-                     'where value_1 in %s and value_2=%s order by value_1'
+            'where value_1 in %s and value_2=%s order by value_1'
         data = [
             [('a',), '\u0430'],
             [['b'], '\u0430'],
@@ -420,7 +428,7 @@ class TestGitHubIssues(base.PyMySQLTestCase):
         self.assertEqual(cur.execute(sql_insert, data[0]), 1)
         self.assertEqual(cur.execute(sql_insert, data[1]), 1)
         self.assertEqual(cur.execute(sql_dict_insert, data[2]), 1)
-        self.assertEqual(cur.execute(sql_select, [('a', 'b', 'c'), '\u0430']), 3)
+        self.assertIn(cur.execute(sql_select, [('a', 'b', 'c'), '\u0430']), [3, -1])
         self.assertEqual(cur.fetchone(), ('a', '\u0430'))
         self.assertEqual(cur.fetchone(), ('b', '\u0430'))
         self.assertEqual(cur.fetchone(), ('c', '\u0430'))

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_load_local.py

@@ -1,17 +1,17 @@
 # type: ignore
 import os
 
-from singlestoredb.clients.pymysqlsv import cursors
-from singlestoredb.clients.pymysqlsv import OperationalError
-from singlestoredb.clients.pymysqlsv import Warning
-from singlestoredb.clients.pymysqlsv.tests import base
+from singlestoredb.mysql import cursors
+from singlestoredb.mysql import OperationalError
+from singlestoredb.mysql.tests import base
 
 __all__ = ['TestLoadLocal']
 
 
 class TestLoadLocal(base.PyMySQLTestCase):
+
     def test_no_file(self):
-        """Test load local infile when the file does not exist"""
+        """Test load local infile when the file does not exist."""
         conn = self.connect()
         c = conn.cursor()
         c.execute('CREATE TABLE test_load_local (a INTEGER, b INTEGER, c TEXT)')
@@ -29,7 +29,7 @@ class TestLoadLocal(base.PyMySQLTestCase):
             c.close()
 
     def test_load_file(self):
-        """Test load local infile with a valid file"""
+        """Test load local infile with a valid file."""
         conn = self.connect()
         c = conn.cursor()
         c.execute('CREATE TABLE test_load_local (a INTEGER, b INTEGER, c TEXT)')
@@ -38,7 +38,8 @@ class TestLoadLocal(base.PyMySQLTestCase):
         )
         try:
             c.execute(
-                f"LOAD DATA LOCAL INFILE '{filename}' INTO TABLE test_load_local FIELDS TERMINATED BY ','",
+                f"LOAD DATA LOCAL INFILE '{filename}' INTO TABLE test_load_local "
+                "FIELDS TERMINATED BY ','",
             )
             c.execute('SELECT COUNT(*) FROM test_load_local')
             self.assertEqual(22749, c.fetchone()[0])
@@ -46,16 +47,17 @@ class TestLoadLocal(base.PyMySQLTestCase):
             c.execute('DROP TABLE test_load_local')
 
     def test_unbuffered_load_file(self):
-        """Test unbuffered load local infile with a valid file"""
-        conn = self.connect()
-        c = conn.cursor(cursors.SSCursor)
+        """Test unbuffered load local infile with a valid file."""
+        conn = self.connect(cursorclass=cursors.SSCursor)
+        c = conn.cursor()
         c.execute('CREATE TABLE test_load_local (a INTEGER, b INTEGER, c TEXT)')
         filename = os.path.join(
             os.path.dirname(os.path.realpath(__file__)), 'data', 'load_local_data.txt',
         )
         try:
             c.execute(
-                f"LOAD DATA LOCAL INFILE '{filename}' INTO TABLE test_load_local FIELDS TERMINATED BY ','",
+                f"LOAD DATA LOCAL INFILE '{filename}' INTO TABLE test_load_local "
+                "FIELDS TERMINATED BY ','",
             )
             c.execute('SELECT COUNT(*) FROM test_load_local')
             self.assertEqual(22749, c.fetchone()[0])

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_nextset.py

@@ -1,12 +1,13 @@
 # type: ignore
 import pytest
 
-import singlestoredb.clients.pymysqlsv as sv
-from singlestoredb.clients.pymysqlsv.constants import CLIENT
-from singlestoredb.clients.pymysqlsv.tests import base
+import singlestoredb.mysql as sv
+from singlestoredb.mysql.constants import CLIENT
+from singlestoredb.mysql.tests import base
 
 
 class TestNextset(base.PyMySQLTestCase):
+
     def test_nextset(self):
         con = self.connect(
             init_command='SELECT "bar"; SELECT "baz"',
@@ -34,6 +35,9 @@ class TestNextset(base.PyMySQLTestCase):
         con = self.connect(client_flag=CLIENT.MULTI_STATEMENTS)
         cur = con.cursor()
 
+        if type(cur).__name__.startswith('SS'):
+            self.skipTest('nextset in unbuffered cursor closes connection')
+
         for i in range(3):
             cur.execute('SELECT %s; xyzzy;', (i,))
             self.assertEqual([(i,)], list(cur))

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_optionfile.py

@@ -2,7 +2,7 @@
 from io import StringIO
 from unittest import TestCase
 
-from singlestoredb.clients.pymysqlsv.optionfile import Parser
+from singlestoredb.mysql.optionfile import Parser
 
 
 __all__ = ['TestParser']
@@ -18,6 +18,7 @@ skip-slave-start
 
 
 class TestParser(TestCase):
+
     def test_string(self):
         parser = Parser()
         parser.read_file(StringIO(_cfg_file))

singlestoredb/{clients/pymysqlsv → mysql}/tests/thirdparty/__init__.py

@@ -1,4 +1,4 @@
-from .test_MySQLdb import *
+from .test_MySQLdb import *  # noqa: F403, F401
 
 if __name__ == '__main__':
     import unittest

singlestoredb/mysql/tests/thirdparty/test_MySQLdb/__init__.py

@@ -0,0 +1,9 @@
+# type: ignore
+from .test_MySQLdb_capabilities import test_MySQLdb as test_capabilities  # noqa: F401
+from .test_MySQLdb_dbapi20 import test_MySQLdb as test_dbapi2  # noqa: F401
+from .test_MySQLdb_nonstandard import *  # noqa: F401, F403
+
+if __name__ == '__main__':
+    import unittest
+
+    unittest.main()

singlestoredb/{clients/pymysqlsv → mysql}/tests/thirdparty/test_MySQLdb/capabilities.py

@@ -5,7 +5,6 @@
     Adapted from a script by M-A Lemburg.
 
 """
-import sys
 import unittest
 from time import time
 
@@ -74,6 +73,7 @@ class DatabaseTest(unittest.TestCase):
         generator must be a function taking arguments (row_number,
         col_number) returning a suitable data object for insertion
         into the table.
+
         """
         self.table = self.new_table_name()
         self.cursor.execute(
@@ -86,7 +86,7 @@ class DatabaseTest(unittest.TestCase):
         self.create_table(columndefs)
         insert_statement = 'INSERT INTO %s VALUES (%s)' % (
             self.table,
-            ','.join(['%s'] * len(columndefs)),
+            ','.join('%s' for x in range(len(columndefs))),
         )
         data = [
             [generator(i, j) for j in range(len(columndefs))] for i in range(self.rows)
@@ -100,14 +100,14 @@ class DatabaseTest(unittest.TestCase):
             'select * from %s ORDER BY %s' %
             (self.table, columndefs[0].split()[0]),
         )
-        l = self.cursor.fetchall()
+        out = self.cursor.fetchall()
         if self.debug:
-            print(l)
-        self.assertEqual(len(l), self.rows)
+            print(out)
+        self.assertEqual(len(out), self.rows)
         try:
             for i in range(self.rows):
                 for j in range(len(columndefs)):
-                    self.assertEqual(l[i][j], generator(i, j))
+                    self.assertEqual(out[i][j], generator(i, j))
         finally:
             if not self.debug:
                 self.cursor.execute('drop table %s' % (self.table))
@@ -124,7 +124,7 @@ class DatabaseTest(unittest.TestCase):
         self.create_table(columndefs)
         insert_statement = 'INSERT INTO %s VALUES (%s)' % (
             self.table,
-            ','.join(['%s'] * len(columndefs)),
+            ','.join('%s' for x in range(len(columndefs))),
         )
         data = [
             [generator(i, j) for j in range(len(columndefs))] for i in range(self.rows)
@@ -136,20 +136,20 @@ class DatabaseTest(unittest.TestCase):
             'select * from %s ORDER BY %s' %
             (self.table, columndefs[0].split()[0]),
         )
-        l = self.cursor.fetchall()
-        self.assertEqual(len(l), self.rows)
+        out = self.cursor.fetchall()
+        self.assertEqual(len(out), self.rows)
         for i in range(self.rows):
             for j in range(len(columndefs)):
-                self.assertEqual(l[i][j], generator(i, j))
+                self.assertEqual(out[i][j], generator(i, j))
         delete_statement = 'delete from %s where col1=%%s' % self.table
         self.cursor.execute(delete_statement, (0,))
         self.cursor.execute('select col1 from %s where col1=%s' % (self.table, 0))
-        l = self.cursor.fetchall()
-        self.assertFalse(l, "DELETE didn't work")
+        out = self.cursor.fetchall()
+        self.assertFalse(out, "DELETE didn't work")
         self.connection.rollback()
         self.cursor.execute('select col1 from %s where col1=%s' % (self.table, 0))
-        l = self.cursor.fetchall()
-        self.assertTrue(len(l) == 1, "ROLLBACK didn't work")
+        out = self.cursor.fetchall()
+        self.assertTrue(len(out) == 1, "ROLLBACK didn't work")
         self.cursor.execute('drop table %s' % (self.table))
 
     @pytest.mark.skip(reason='SingleStoreDB does not surface a warning')
@@ -165,7 +165,7 @@ class DatabaseTest(unittest.TestCase):
         self.create_table(columndefs)
         insert_statement = 'INSERT INTO %s VALUES (%s)' % (
             self.table,
-            ','.join(['%s'] * len(columndefs)),
+            ','.join('%s' for x in range(len(columndefs))),
         )
 
         try:
@@ -195,7 +195,8 @@ class DatabaseTest(unittest.TestCase):
             pass
         else:
             self.fail(
-                'Over-long columns did not generate warnings/exception with execute()',
+                'Over-long columns did not generate warnings/exception '
+                'with execute()',
             )
 
         self.connection.rollback()
@@ -213,7 +214,8 @@ class DatabaseTest(unittest.TestCase):
             pass
         else:
             self.fail(
-                'Over-long columns did not generate warnings/exception with executemany()',
+                'Over-long columns did not generate warnings/exception '
+                'with executemany()',
             )
 
         self.connection.rollback()