singlestoredb 0.3.3__py3-none-any.whl → 1.0.3__py3-none-any.whl

singlestoredb/tests/test_connection.py

@@ -1,20 +1,16 @@
 #!/usr/bin/env python
 # type: ignore
 """Basic SingleStoreDB connection testing."""
-from __future__ import annotations
-
 import datetime
 import decimal
 import os
 import unittest
 import uuid
-import warnings
-
-import pandas as pd
 
 import singlestoredb as s2
 from singlestoredb import connection as sc
 from singlestoredb.tests import utils
+# import pandas as pd
 # import traceback
 
 
@@ -36,9 +32,6 @@ class TestConnection(unittest.TestCase):
     def setUp(self):
         self.conn = s2.connect(database=type(self).dbname, local_infile=True)
         self.cur = self.conn.cursor()
-        self.driver = self.conn._driver.dbapi.__name__.replace(
-            'singlestoredb.', '',
-        )
 
     def tearDown(self):
         try:
@@ -83,16 +76,16 @@ class TestConnection(unittest.TestCase):
         assert cbp('enable') is True, cbp('enable')
         assert cbp('enabled') is True, cbp('enabled')
 
-        assert cbp('false') is True, cbp('false')
-        assert cbp('f') is True, cbp('f')
-        assert cbp('False') is True, cbp('False')
-        assert cbp('F') is True, cbp('F')
-        assert cbp('FALSE') is True, cbp('FALSE')
+        assert cbp('false') is False, cbp('false')
+        assert cbp('f') is False, cbp('f')
+        assert cbp('False') is False, cbp('False')
+        assert cbp('F') is False, cbp('F')
+        assert cbp('FALSE') is False, cbp('FALSE')
 
-        assert cbp('off') is True, cbp('off')
-        assert cbp('no') is True, cbp('no')
-        assert cbp('disable') is True, cbp('disable')
-        assert cbp('disabled') is True, cbp('disabled')
+        assert cbp('off') is False, cbp('off')
+        assert cbp('no') is False, cbp('no')
+        assert cbp('disable') is False, cbp('disable')
+        assert cbp('disabled') is False, cbp('disabled')
 
         with self.assertRaises(ValueError):
             cbp('nein')
@@ -121,7 +114,7 @@ class TestConnection(unittest.TestCase):
             ('e', 'elephants', 0),
         ]), out
 
-        assert rowcount == 5, rowcount
+        assert rowcount in (5, -1), rowcount
         assert rownumber == 5, rownumber
         assert lastrowid is None, lastrowid
         assert len(desc) == 3, desc
@@ -156,7 +149,7 @@ class TestConnection(unittest.TestCase):
             ('e', 'elephants', 0),
         ]), out
 
-        assert rowcount == 5, rowcount
+        assert rowcount in (5, -1), rowcount
         assert rownumber == 5, rownumber
         assert lastrowid is None, lastrowid
         assert len(desc) == 3, desc
@@ -192,7 +185,7 @@ class TestConnection(unittest.TestCase):
             ('e', 'elephants', 0),
         ]), out
 
-        assert rowcount == 5, rowcount
+        assert rowcount in (5, -1), rowcount
         assert rownumber == 5, rownumber
         assert lastrowid is None, lastrowid
         assert len(desc) == 3, desc
@@ -229,7 +222,7 @@ class TestConnection(unittest.TestCase):
         assert self.cur.rownumber == 5, self.cur.rownumber
 
     def test_execute_with_dict_params(self):
-        self.cur.execute('select * from data where id < :name', dict(name='d'))
+        self.cur.execute('select * from data where id < %(name)s', dict(name='d'))
         out = self.cur.fetchall()
 
         desc = self.cur.description
@@ -242,7 +235,7 @@ class TestConnection(unittest.TestCase):
             ('c', 'cats', 5),
         ]), out
 
-        assert rowcount == 3, rowcount
+        assert rowcount in (3, -1), rowcount
         assert lastrowid is None, lastrowid
         assert len(desc) == 3, desc
         assert desc[0].name == 'id', desc[0].name
@@ -253,7 +246,7 @@ class TestConnection(unittest.TestCase):
         assert desc[2].type_code == 8, desc[2].type_code
 
     def test_execute_with_positional_params(self):
-        self.cur.execute('select * from data where id < :1', ['d'])
+        self.cur.execute('select * from data where id < %s', ['d'])
         out = self.cur.fetchall()
 
         desc = self.cur.description
@@ -266,7 +259,7 @@ class TestConnection(unittest.TestCase):
             ('c', 'cats', 5),
         ]), out
 
-        assert rowcount == 3, rowcount
+        assert rowcount in (3, -1), rowcount
         assert lastrowid is None, lastrowid
         assert len(desc) == 3, desc
         assert desc[0].name == 'id', desc[0].name
@@ -278,7 +271,7 @@ class TestConnection(unittest.TestCase):
 
     def test_execute_with_escaped_positional_substitutions(self):
         self.cur.execute(
-            'select `id`, `time` from alltypes where `time` = :1', [
+            'select `id`, `time` from alltypes where `time` = %s', [
                 '00:07:00',
             ],
         )
@@ -291,44 +284,44 @@ class TestConnection(unittest.TestCase):
         out = self.cur.fetchall()
         assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
 
-        with self.assertRaises(IndexError):
-            self.cur.execute(
-                'select `id`, `time` from alltypes where `id` = :1 '
-                'or `time` = "00:07:00"', [0],
-            )
+#       with self.assertRaises(IndexError):
+#           self.cur.execute(
+#               'select `id`, `time` from alltypes where `id` = %1s '
+#               'or `time` = "00:07:00"', [0],
+#           )
 
         self.cur.execute(
-            'select `id`, `time` from alltypes where `id` = :1 '
-            'or `time` = "00::07::00"', [0],
+            'select `id`, `time` from alltypes where `id` = %s '
+            'or `time` = "00:07:00"', [0],
         )
         out = self.cur.fetchall()
         assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
 
     def test_execute_with_escaped_substitutions(self):
         self.cur.execute(
-            'select `id`, `time` from alltypes where `time` = :time',
+            'select `id`, `time` from alltypes where `time` = %(time)s',
             dict(time='00:07:00'),
         )
         out = self.cur.fetchall()
         assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
 
         self.cur.execute(
-            'select `id`, `time` from alltypes where `time` = :time',
-            dict(time='00::07::00'),
+            'select `id`, `time` from alltypes where `time` = %(time)s',
+            dict(time='00:07:00'),
         )
         out = self.cur.fetchall()
-        assert len(out) == 0, out
+        assert len(out) == 1, out
 
         with self.assertRaises(KeyError):
             self.cur.execute(
                 'select `id`, `time`, `char_100` from alltypes '
-                'where `time` = :time or `char_100` like "foo:bar"',
-                dict(time='00:07:00'),
+                'where `time` = %(time)s or `char_100` like "foo:bar"',
+                dict(x='00:07:00'),
             )
 
         self.cur.execute(
             'select `id`, `time`, `char_100` from alltypes '
-            'where `time` = :time or `char_100` like "foo::bar"',
+            'where `time` = %(time)s or `char_100` like "foo::bar"',
             dict(time='00:07:00'),
         )
         out = self.cur.fetchall()
@@ -352,7 +345,7 @@ class TestConnection(unittest.TestCase):
     def test_executemany(self):
         # NOTE: Doesn't actually do anything since no rows match
         self.cur.executemany(
-            'delete from data where id > :name',
+            'delete from data where id > %(name)s',
             [dict(name='z'), dict(name='y')],
         )
 
@@ -541,8 +534,6 @@ class TestConnection(unittest.TestCase):
         with self.assertRaises(s2.ProgrammingError) as cm:
             self.cur.execute('garbage syntax')
         exc = cm.exception
-        if self.driver != 'pyodbc':
-            assert exc.errno == 1064, exc.errno
         assert 'You have an error in your SQL syntax' in exc.errmsg, exc.errmsg
 
     def test_alltypes(self):
@@ -555,30 +546,8 @@ class TestConnection(unittest.TestCase):
 
         bits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
 
-        if self.driver == 'pyodbc':
-            odbc_types = {
-                # int -> bigint
-                3: 8, 1: 8, 2: 8, 9: 8,
-                # float -> double
-                4: 5,
-                # timestamp -> datetime
-                7: 12,
-                # year -> bigint
-                13: 8,
-                # char/binary -> varchar/varbinary
-                249: 15, 250: 15, 251: 15, 252: 15, 253: 15, 254: 15, 255: 15,
-                # newdecimal -> decimal
-                246: 0,
-                # json -> varchar
-                245: 15,
-                # bit -> varchar
-                16: 15,
-            }
-        else:
-            odbc_types = {}
-
         def otype(x):
-            return odbc_types.get(x, x)
+            return x
 
         assert row['id'] == 0, row['id']
         assert typ['id'] == otype(3), typ['id']
@@ -664,11 +633,6 @@ class TestConnection(unittest.TestCase):
         assert row['time'] == datetime.timedelta(minutes=7), row['time']
         assert typ['time'] == 11, typ['time']
 
-        # pyodbc doesn't support microseconds on times
-        if not self.driver == 'pyodbc':
-            assert row['time_6'] == datetime.timedelta(
-                hours=1, minutes=10, microseconds=2,
-            ), row['time_6']
         assert typ['time_6'] == 11, typ['time_6']
 
         assert row['datetime'] == datetime.datetime(
@@ -742,14 +706,10 @@ class TestConnection(unittest.TestCase):
         ), row['tinyblob']
         assert typ['tinyblob'] == otype(249), typ['tinyblob']
 
-        # pyodbc surfaces json as varchar
-        if self.driver == 'pyodbc':
-            assert row['json'] == '{"a":10,"b":2.75,"c":"hello world"}', row['json']
-        else:
-            assert row['json'] == {
-                'a': 10, 'b': 2.75,
-                'c': 'hello world',
-            }, row['json']
+        assert row['json'] == {
+            'a': 10, 'b': 2.75,
+            'c': 'hello world',
+        }, row['json']
         assert typ['json'] == otype(245), typ['json']
 
         assert row['enum'] == 'one', row['enum']
@@ -758,10 +718,7 @@ class TestConnection(unittest.TestCase):
         assert row['set'] == 'two', row['set']
         assert typ['set'] == otype(253), typ['set']  # mysql code: 248
 
-        if self.driver == 'pyodbc':
-            assert row['bit'] == b'\x80\x00\x00\x00\x00\x00\x00\x00', row['bit']
-        else:
-            assert row['bit'] == b'\x00\x00\x00\x00\x00\x00\x00\x80', row['bit']
+        assert row['bit'] == b'\x00\x00\x00\x00\x00\x00\x00\x80', row['bit']
         assert typ['bit'] == otype(16), typ['bit']
 
     def test_alltypes_nulls(self):
@@ -772,30 +729,8 @@ class TestConnection(unittest.TestCase):
         row = dict(zip(names, out))
         typ = dict(zip(names, types))
 
-        if self.driver == 'pyodbc':
-            odbc_types = {
-                # int -> bigint
-                3: 8, 1: 8, 2: 8, 9: 8,
-                # float -> double
-                4: 5,
-                # timestamp -> datetime
-                7: 12,
-                # year -> bigint
-                13: 8,
-                # char/binary -> varchar/varbinary
-                249: 15, 250: 15, 251: 15, 252: 15, 253: 15, 254: 15, 255: 15,
-                # newdecimal -> decimal
-                246: 0,
-                # json -> varchar
-                245: 15,
-                # bit -> varchar
-                16: 15,
-            }
-        else:
-            odbc_types = {}
-
         def otype(x):
-            return odbc_types.get(x, x)
+            return x
 
         assert row['id'] == 1, row['id']
         assert typ['id'] == otype(3), typ['id']
@@ -924,78 +859,6 @@ class TestConnection(unittest.TestCase):
         assert row['bit'] is None, row['bit']
         assert typ['bit'] == otype(16), typ['bit']
 
-    def test_convert_exception(self):
-        driver = self.conn._driver
-        dbapi = driver.dbapi
-
-        if self.driver in ['mysql.connector', 'http', 'https']:
-            exc_args = tuple()
-            exc_kwargs = dict(errno=-1, msg='hi there')
-        else:
-            exc_args = (-1, 'hi there')
-            exc_kwargs = {}
-
-        exc = driver.convert_exception(
-            dbapi.NotSupportedError(*exc_args, **exc_kwargs),
-        )
-        assert exc.args[0] == -1
-        assert exc.args[1] == 'hi there'
-        assert exc.errno == -1
-        assert exc.errmsg == 'hi there'
-        assert exc.msg == 'hi there'
-
-        with self.assertRaises(s2.NotSupportedError):
-            raise driver.convert_exception(
-                dbapi.NotSupportedError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.ProgrammingError):
-            raise driver.convert_exception(
-                dbapi.ProgrammingError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.InternalError):
-            raise driver.convert_exception(
-                dbapi.InternalError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.IntegrityError):
-            raise driver.convert_exception(
-                dbapi.IntegrityError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.OperationalError):
-            raise driver.convert_exception(
-                dbapi.OperationalError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.DataError):
-            raise driver.convert_exception(
-                dbapi.DataError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.DatabaseError):
-            raise driver.convert_exception(
-                dbapi.DatabaseError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.InterfaceError):
-            raise driver.convert_exception(
-                dbapi.InterfaceError(*exc_args, **exc_kwargs),
-            )
-
-        with self.assertRaises(s2.Error):
-            raise driver.convert_exception(
-                dbapi.Error(*exc_args, **exc_kwargs),
-            )
-
-        if self.driver == 'mariadb':
-            with self.assertRaises(s2.Error):
-                raise driver.convert_exception(dbapi.Warning('hi there'))
-        else:
-            with self.assertRaises(s2.Warning):
-                raise driver.convert_exception(dbapi.Warning('hi there'))
-
     def test_name_check(self):
         nc = sc._name_check
         assert nc('foo') == 'foo'
@@ -1016,46 +879,31 @@ class TestConnection(unittest.TestCase):
         self.cur.execute('echo return_int()')
 
         out = self.cur.fetchall()
-        assert out == [(1234567890,)], out
-
-        # These take an extra `nextset` for some reason
-        if self.driver in ['pymysql', 'MySQLdb', 'cymysql', 'pyodbc']:
-            self.cur.nextset()
+        assert list(out) == [(1234567890,)], out
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_echo_with_result_set(self):
         self.cur.execute('echo result_set_and_return_int()')
 
         out = self.cur.fetchall()
-        assert out == [(5,)], out
-
-        if self.driver == 'mysql.connector' and s2.get_option('pure_python'):
-            warnings.warn(
-                'The mysql.connector in pure python mode does not '
-                'support multiple result sets.',
-            )
-            return
+        assert list(out) == [(5,)], out
 
         out = self.cur.nextset()
         assert out is True, out
 
         out = self.cur.fetchall()
-        assert out == [(1, 2, 3)], out
+        assert list(out) == [(1, 2, 3)], out
 
         out = self.cur.nextset()
         assert out is True, out
 
         out = self.cur.fetchall()
-        assert out == [(1234567890,)], out
-
-        # These take an extra `nextset` for some reason
-        if self.driver in ['pymysql', 'MySQLdb', 'cymysql', 'pyodbc']:
-            self.cur.nextset()
+        assert list(out) == [(1234567890,)], out
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_callproc(self):
         self.cur.callproc('get_animal', ['cats'])
@@ -1063,25 +911,21 @@ class TestConnection(unittest.TestCase):
         out = self.cur.fetchall()
         assert list(out) == [(5,)], out
 
-        if self.driver == 'mysql.connector' and s2.get_option('pure_python'):
-            warnings.warn(
-                'The mysql.connector in pure python mode does not '
-                'support multiple result sets.',
-            )
-            return
-
         out = self.cur.nextset()
         assert out is True, out
 
         out = self.cur.fetchall()
         assert list(out) == [(1, 2, 3)], out
 
-        # These take an extra `nextset` for some reason
-        if self.driver in ['pymysql', 'MySQLdb', 'cymysql', 'pyodbc']:
-            self.cur.nextset()
+        out = self.cur.nextset()
+        assert out is True, out
+
+        # Always get an empty set at the end
+        out = self.cur.fetchall()
+        assert list(out) == [], out
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_callproc_no_args(self):
         self.cur.callproc('no_args')
@@ -1089,38 +933,37 @@ class TestConnection(unittest.TestCase):
         out = self.cur.fetchall()
         assert list(out) == [(4, 5, 6)], out
 
-        # These take an extra `nextset` for some reason
-        if self.driver in ['pymysql', 'MySQLdb', 'cymysql', 'pyodbc']:
-            self.cur.nextset()
+        out = self.cur.nextset()
+        assert out is True, out
+
+        # Always get an empty set at the end
+        out = self.cur.fetchall()
+        assert list(out) == [], out
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_callproc_return_int(self):
         self.cur.callproc('result_set_and_return_int')
 
         out = self.cur.fetchall()
-        assert out == [(5,)], out
-
-        if self.driver == 'mysql.connector' and s2.get_option('pure_python'):
-            warnings.warn(
-                'The mysql.connector in pure python mode does not '
-                'support multiple result sets.',
-            )
-            return
+        assert list(out) == [(5,)], out
 
         out = self.cur.nextset()
         assert out is True, out
 
         out = self.cur.fetchall()
-        assert out == [(1, 2, 3)], out
+        assert list(out) == [(1, 2, 3)], out
 
-        # These take an extra `nextset` for some reason
-        if self.driver in ['pymysql', 'MySQLdb', 'cymysql', 'pyodbc']:
-            self.cur.nextset()
+        out = self.cur.nextset()
+        assert out is True, out
+
+        # Always get an empty set at the end
+        out = self.cur.fetchall()
+        assert list(out) == [], out
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_callproc_bad_args(self):
         self.cur.callproc('get_animal', [10])
@@ -1128,31 +971,28 @@ class TestConnection(unittest.TestCase):
         out = self.cur.fetchall()
         assert list(out) == [], out
 
-        if self.driver == 'mysql.connector' and s2.get_option('pure_python'):
-            warnings.warn(
-                'The mysql.connector in pure python mode does not '
-                'support multiple result sets.',
-            )
-            return
-
         out = self.cur.nextset()
         assert out is True, out
 
         out = self.cur.fetchall()
         assert list(out) == [(1, 2, 3)], out
 
-        # These take an extra `nextset` for some reason
-        if self.driver in ['pymysql', 'MySQLdb', 'cymysql', 'pyodbc']:
-            self.cur.nextset()
+        out = self.cur.nextset()
+        assert out is True, out
+
+        # Always get an empty set at the end
+        out = self.cur.fetchall()
+        assert list(out) == [], out
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_callproc_too_many_args(self):
         with self.assertRaises((
             s2.ProgrammingError,
             s2.OperationalError,
             s2.InternalError,
+            TypeError,
         )):
             self.cur.callproc('get_animal', ['cats', 'dogs'])
 
@@ -1160,6 +1000,7 @@ class TestConnection(unittest.TestCase):
             s2.ProgrammingError,
             s2.OperationalError,
             s2.InternalError,
+            TypeError,
         )):
             self.cur.callproc('get_animal', [])
 
@@ -1167,43 +1008,43 @@ class TestConnection(unittest.TestCase):
             s2.ProgrammingError,
             s2.OperationalError,
             s2.InternalError,
+            TypeError,
         )):
             self.cur.callproc('get_animal')
 
     def test_cursor_close(self):
         self.cur.close()
 
-        with self.assertRaises(s2.InterfaceError):
-            self.cur.close()
+        self.cur.close()
 
-        with self.assertRaises(s2.InterfaceError):
+        with self.assertRaises(s2.ProgrammingError):
             self.cur.callproc('foo')
 
-        with self.assertRaises(s2.InterfaceError):
+        with self.assertRaises(s2.ProgrammingError):
             self.cur.execute('select 1')
 
-        with self.assertRaises(s2.InterfaceError):
-            self.cur.executemany('select 1')
+#       with self.assertRaises(s2.ProgrammingError):
+#           self.cur.executemany('select 1')
 
-        with self.assertRaises(s2.InterfaceError):
+        with self.assertRaises(s2.ProgrammingError):
             self.cur.fetchone()
 
-        with self.assertRaises(s2.InterfaceError):
+        with self.assertRaises(s2.ProgrammingError):
             self.cur.fetchall()
 
-        with self.assertRaises(s2.InterfaceError):
+        with self.assertRaises(s2.ProgrammingError):
             self.cur.fetchmany()
 
-        with self.assertRaises(s2.InterfaceError):
+        with self.assertRaises(s2.ProgrammingError):
             self.cur.nextset()
 
-        with self.assertRaises(s2.InterfaceError):
-            self.cur.setinputsizes([])
+#       with self.assertRaises(s2.ProgrammingError):
+#           self.cur.setinputsizes([])
 
-        with self.assertRaises(s2.InterfaceError):
-            self.cur.setoutputsize(10)
+#       with self.assertRaises(s2.ProgrammingError):
+#           self.cur.setoutputsize(10)
 
-        with self.assertRaises(s2.InterfaceError):
+        with self.assertRaises(s2.ProgrammingError):
             self.cur.scroll(2)
 
         with self.assertRaises(s2.InterfaceError):
@@ -1221,15 +1062,9 @@ class TestConnection(unittest.TestCase):
         self.cur.setinputsizes([10, 20, 30])
 
     def test_setoutputsize(self):
-        if self.driver in ['MySQLdb', 'pymysql', 'cymysql']:
-            self.skipTest('outputsize is not supported')
-
         self.cur.setoutputsize(100)
 
     def test_scroll(self):
-        if self.driver in ['mysql.connector', 'pyodbc', 'mariadb', 'cymysql']:
-            self.skipTest('scroll is not supported')
-
         self.cur.execute('select * from data order by name')
 
         out = self.cur.fetchone()
@@ -1242,19 +1077,21 @@ class TestConnection(unittest.TestCase):
         assert out[1] == 'elephants', out[1]
         assert self.cur.rownumber == 5, self.cur.rownumber
 
-        self.cur.scroll(0, mode='absolute')
-
-        assert self.cur.rownumber == 0, self.cur.rownumber
+        try:
+            self.cur.scroll(0, mode='absolute')
+            assert self.cur.rownumber == 0, self.cur.rownumber
 
-        out = self.cur.fetchone()
-        assert out[1] == 'antelopes', out[1]
-        assert self.cur.rownumber == 1, self.cur.rownumber
+            out = self.cur.fetchone()
+            assert out[1] == 'antelopes', out[1]
+            assert self.cur.rownumber == 1, self.cur.rownumber
+        except s2.NotSupportedError:
+            pass
 
         with self.assertRaises((ValueError, s2.ProgrammingError)):
             self.cur.scroll(0, mode='badmode')
 
     def test_autocommit(self):
-        if self.driver in ['http', 'https']:
+        if self.conn.driver in ['http', 'https']:
             self.skipTest('Can not set autocommit in HTTP')
 
         orig = self.conn.locals.autocommit
@@ -1272,10 +1109,11 @@ class TestConnection(unittest.TestCase):
     def test_conn_close(self):
         self.conn.close()
 
-        self.conn.close()
+        with self.assertRaises(s2.Error):
+            self.conn.close()
 
         with self.assertRaises(s2.InterfaceError):
-            self.conn.autocommit()
+            self.conn.autocommit(False)
 
         with self.assertRaises(s2.InterfaceError):
             self.conn.commit()
@@ -1283,11 +1121,11 @@ class TestConnection(unittest.TestCase):
         with self.assertRaises(s2.InterfaceError):
             self.conn.rollback()
 
-        with self.assertRaises(s2.InterfaceError):
-            self.conn.cursor()
+#       with self.assertRaises(s2.InterfaceError):
+#           self.conn.cursor()
 
-        with self.assertRaises(s2.InterfaceError):
-            self.conn.messages
+#       with self.assertRaises(s2.InterfaceError):
+#           self.conn.messages
 
         with self.assertRaises(s2.InterfaceError):
             self.conn.globals.autocommit = True
@@ -1308,7 +1146,7 @@ class TestConnection(unittest.TestCase):
             self.conn.disable_data_api()
 
     def test_rollback(self):
-        if self.driver in ['http', 'https']:
+        if self.conn.driver in ['http', 'https']:
             self.skipTest('Can not set autocommit in HTTP')
 
         self.conn.autocommit(False)
@@ -1330,7 +1168,7 @@ class TestConnection(unittest.TestCase):
         assert len(out) == 5, len(out)
 
     def test_commit(self):
-        if self.driver in ['http', 'https']:
+        if self.conn.driver in ['http', 'https']:
             self.skipTest('Can not set autocommit in HTTP')
 
         self.conn.autocommit(False)
@@ -1379,7 +1217,7 @@ class TestConnection(unittest.TestCase):
         assert val == orig, val
 
     def test_session_var(self):
-        if self.driver in ['http', 'https']:
+        if self.conn.driver in ['http', 'https']:
             self.skipTest('Can not change session variable in HTTP')
 
         orig = self.conn.locals.enable_multipartition_queries
@@ -1397,7 +1235,7 @@ class TestConnection(unittest.TestCase):
         assert val == orig, val
 
     def test_local_infile(self):
-        if self.driver in ['http', 'https']:
+        if self.conn.driver in ['http', 'https']:
             self.skipTest('Can not load local files in HTTP')
 
         path = os.path.join(os.path.dirname(__file__), 'local_infile.csv')
@@ -1413,16 +1251,16 @@ class TestConnection(unittest.TestCase):
 
         try:
             self.cur.execute(
-                f'load data local infile :1 into table {tblname} '
+                f'load data local infile %s into table {tblname} '
                 'fields terminated by "," lines terminated by "\n";', [path],
             )
 
-            self.cur.execute(f'select * from {tblname};')
+            self.cur.execute(f'select * from {tblname} order by first_name')
             out = list(self.cur)
             assert out == [
                 ('John', 'Doe', 34),
-                ('Sandy', 'Smith', 24),
                 ('Patty', 'Jones', 57),
+                ('Sandy', 'Smith', 24),
             ], out
 
         finally:
@@ -1444,7 +1282,7 @@ class TestConnection(unittest.TestCase):
             254: upper,
         }
 
-        with s2.connect(database=type(self).dbname, converters=convs) as conn:
+        with s2.connect(database=type(self).dbname, conv=convs) as conn:
             with conn.cursor() as cur:
                 cur.execute('select * from alltypes where id = 0')
                 names = [x[0] for x in cur.description]
@@ -1474,7 +1312,7 @@ class TestConnection(unittest.TestCase):
                 assert row['tinytext'] == 'This is a tinytext column.', \
                     row['tinytext']
 
-    def test_results_format(self):
+    def test_results_type(self):
         columns = [
             'id', 'tinyint', 'unsigned_tinyint', 'bool', 'boolean',
             'smallint', 'unsigned_smallint', 'mediumint', 'unsigned_mediumint',
@@ -1488,33 +1326,147 @@ class TestConnection(unittest.TestCase):
             'set', 'bit',
         ]
 
-        with s2.connect(database=type(self).dbname, results_format='tuple') as conn:
+        with s2.connect(database=type(self).dbname, results_type='tuples') as conn:
             with conn.cursor() as cur:
                 cur.execute('select * from alltypes')
                 out = cur.fetchall()
                 assert type(out[0]) is tuple, type(out[0])
                 assert len(out[0]) == len(columns), len(out[0])
 
-        with s2.connect(database=type(self).dbname, results_format='namedtuple') as conn:
+        with s2.connect(database=type(self).dbname, results_type='namedtuples') as conn:
             with conn.cursor() as cur:
                 cur.execute('select * from alltypes')
                 out = cur.fetchall()
                 assert type(out[0]).__name__ == 'Row', type(out)
-                assert list(out[0]._fields) == columns, out[0]._fields
+                for i, name in enumerate(columns):
+                    assert hasattr(out[0], name)
+                    assert out[0][i] == getattr(out[0], name)
 
-        with s2.connect(database=type(self).dbname, results_format='dict') as conn:
+        with s2.connect(database=type(self).dbname, results_type='dicts') as conn:
             with conn.cursor() as cur:
                 cur.execute('select * from alltypes')
                 out = cur.fetchall()
                 assert type(out[0]) is dict, type(out)
                 assert list(out[0].keys()) == columns, out[0].keys()
 
-        with s2.connect(database=type(self).dbname, results_format='dataframe') as conn:
+    def test_results_format(self):
+        with self.assertWarns(DeprecationWarning):
+            with s2.connect(database=type(self).dbname, results_format='dicts') as conn:
+                with conn.cursor() as cur:
+                    cur.execute('select * from alltypes')
+                    out = cur.fetchall()
+                    assert type(out[0]) is dict, type(out)
+
+    def test_multi_statements(self):
+        if self.conn.driver not in ['http', 'https']:
+            with s2.connect(database=type(self).dbname, multi_statements=True) as conn:
+                with conn.cursor() as cur:
+                    cur.execute('SELECT 1; SELECT 2;')
+                    self.assertEqual([(1,)], list(cur))
+
+                    r = cur.nextset()
+                    self.assertTrue(r)
+
+                    self.assertEqual([(2,)], list(cur))
+                    self.assertIsNone(cur.nextset())
+
+    def test_connect_timeout(self):
+        with s2.connect(database=type(self).dbname, connect_timeout=8) as conn:
             with conn.cursor() as cur:
-                cur.execute('select * from alltypes')
-                out = cur.fetchall()
-                assert type(out) is pd.DataFrame, type(out)
-                assert list(out.columns) == columns, out.columns
+                cur.execute('SELECT 1')
+                self.assertEqual([(1,)], list(cur))
+
+    def test_show_accessors(self):
+        out = self.conn.show.columns('data')
+        assert out.columns == [
+            'Name', 'Type', 'Null',
+            'Key', 'Default', 'Extra',
+        ], out.columns
+        assert out.Name == ['id', 'name', 'value'], out.Name
+        assert out.Type == ['varchar(255)', 'varchar(255)', 'bigint(20)'], out.Type
+        assert str(out).count('varchar(255)') == 2, out
+
+        html = out._repr_html_()
+        assert html.count('varchar(255)') == 2
+        assert html.count('bigint(20)') == 1
+        assert '<table' in html
+
+        out = self.conn.show.tables()
+        assert out.columns == ['Name'], out.columns
+        assert 'data' in out.Name, out.Name
+        assert 'alltypes' in out.Name, out.Name
+
+        out = self.conn.show.warnings()
+
+        out = self.conn.show.errors()
+
+        out = self.conn.show.databases()
+        assert out.columns == ['Name'], out.columns
+        assert 'information_schema' in out.Name
+
+        out = self.conn.show.database_status()
+        assert out.columns == ['Name', 'Value'], out.columns
+        assert 'database' in out.Name
+
+        out = self.conn.show.global_status()
+        assert out.columns == ['Name', 'Value'], out.columns
+
+        out = self.conn.show.indexes('data')
+        assert 'Name' in out.columns, out.columns
+        assert 'KeyName' in out.columns, out.columns
+        assert out.Name == ['data'], out.Name
+
+        out = self.conn.show.functions()
+
+        out = self.conn.show.partitions()
+        assert 'Name' in out.columns, out.columns
+        assert 'Role' in out.columns, out.columns
+
+        out = self.conn.show.pipelines()
+
+        # out = self.conn.show.plan(1)
+
+        # out = self.conn.show.plancache()
+
+        out = self.conn.show.processlist()
+        assert 'Name' in out.columns, out.columns
+        assert 'Command' in out.columns, out.columns
+
+        # out = self.conn.show.reproduction()
+
+        out = self.conn.show.schemas()
+        assert out.columns == ['Name'], out.columns
+        assert 'information_schema' in out.Name
+
+        out = self.conn.show.session_status()
+        assert out.columns == ['Name', 'Value']
+
+        out = self.conn.show.status()
+        assert out.columns == ['Name', 'Value']
+
+        out = self.conn.show.table_status()
+        assert 'Name' in out.columns, out.columns
+        assert 'alltypes' in out.Name, out.Name
+        assert 'data' in out.Name, out.Name
+
+        out = self.conn.show.procedures()
+
+        out = self.conn.show.aggregates()
+
+        # out = self.conn.show.create_aggregate('aname')
+
+        # out = self.conn.show.create_function('fname')
+
+        # out = self.conn.show.create_pipeline('pname')
+
+        out = self.conn.show.create_table('data')
+        assert 'Name' in out.columns, out.columns
+        assert 'CreateTable' in out.columns, out.columns
+        assert '`id` varchar(255)' in out.CreateTable[0], out.CreateTable[0]
+        assert '`name` varchar(255)' in out.CreateTable[0], out.CreateTable[0]
+        assert '`value` bigint(20)' in out.CreateTable[0], out.CreateTable[0]
+
+        # out = self.conn.show.create_view('vname')
 
 
 if __name__ == '__main__':