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

singlestoredb/tests/test_basics.py

@@ -1,13 +1,33 @@
 #!/usr/bin/env python
 # type: ignore
 """Basic SingleStoreDB connection testing."""
-from __future__ import annotations
-
 import datetime
 import decimal
+import math
 import os
 import unittest
 
+from requests.exceptions import InvalidJSONError
+
+try:
+    import numpy as np
+    has_numpy = True
+except ImportError:
+    has_numpy = False
+
+try:
+    import shapely.wkt
+    has_shapely = True
+except ImportError:
+    has_shapely = False
+
+try:
+    import pygeos
+    from pygeos.testing import assert_geometries_equal
+    has_pygeos = True
+except ImportError:
+    has_pygeos = False
+
 import singlestoredb as s2
 from . import utils
 # import traceback
@@ -31,7 +51,6 @@ class TestBasics(unittest.TestCase):
     def setUp(self):
         self.conn = s2.connect(database=type(self).dbname)
         self.cur = self.conn.cursor()
-        self.driver = self.conn._driver.dbapi.__name__
 
     def tearDown(self):
         try:
@@ -71,7 +90,7 @@ class TestBasics(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
@@ -106,7 +125,7 @@ class TestBasics(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
@@ -142,7 +161,7 @@ class TestBasics(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
@@ -179,7 +198,7 @@ class TestBasics(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
@@ -192,7 +211,7 @@ class TestBasics(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
@@ -202,8 +221,11 @@ class TestBasics(unittest.TestCase):
         assert desc[2].name == 'value', desc[2].name
         assert desc[2].type_code == 8, desc[2].type_code
 
+        with self.assertRaises(KeyError):
+            self.cur.execute('select * from data where id < %(name)s', dict(foo='d'))
+
     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
@@ -216,7 +238,7 @@ class TestBasics(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
@@ -226,74 +248,67 @@ class TestBasics(unittest.TestCase):
         assert desc[2].name == 'value', desc[2].name
         assert desc[2].type_code == 8, desc[2].type_code
 
+        with self.assertRaises(TypeError):
+            self.cur.execute(
+                'select * from data where id < %s and id > %s', ['d', 'e', 'f'],
+            )
+
+        with self.assertRaises(TypeError):
+            self.cur.execute('select * from data where id < %s and id > %s', ['d'])
+
     def test_execute_with_escaped_positional_substitutions(self):
         self.cur.execute(
-            'select `id`, `time` from alltypes where `time` = :1', ['00:07:00'],
+            'select `id`, `time` from alltypes where `time` = %s', ['00:07:00'],
         )
         out = self.cur.fetchall()
-        if self.driver == 'pyodbc':
-            assert out[0] == (0, datetime.time(0, 7)), out[0]
-        else:
-            assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
+        assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
 
         self.cur.execute('select `id`, `time` from alltypes where `time` = "00:07:00"')
         out = self.cur.fetchall()
-        if self.driver == 'pyodbc':
-            assert out[0] == (0, datetime.time(0, 7)), out[0]
-        else:
-            assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
+        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()
-        if self.driver == 'pyodbc':
-            assert out[0] == (0, datetime.time(0, 7)), out[0]
-        else:
-            assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
+        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()
-        if self.driver == 'pyodbc':
-            assert out[0] == (0, datetime.time(0, 7)), out[0]
-        else:
-            assert out[0] == (0, datetime.timedelta(seconds=420)), out[0]
+        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()
-        if self.driver == 'pyodbc':
-            assert out[0][:2] == (0, datetime.time(0, 7)), out[0]
-        else:
-            assert out[0][:2] == (0, datetime.timedelta(seconds=420)), out[0]
+        assert out[0][:2] == (0, datetime.timedelta(seconds=420)), out[0]
 
     def test_is_connected(self):
         assert self.conn.is_connected()
@@ -313,7 +328,7 @@ class TestBasics(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')],
         )
 
@@ -484,10 +499,147 @@ class TestBasics(unittest.TestCase):
             self.cur.execute('garbage syntax')
 
         exc = cm.exception
-        if self.driver != 'pyodbc':
-            assert exc.errno == 1064, exc.errno
+        assert exc.errno == 1064, exc.errno
         assert 'You have an error in your SQL syntax' in exc.errmsg, exc.errmsg
 
+    def test_extended_types(self):
+        if not has_numpy or not has_pygeos or not has_shapely:
+            self.skipTest('Test requires numpy, pygeos, and shapely')
+
+        import uuid
+
+        key = str(uuid.uuid4())
+
+        # shapely data
+        data = [
+            (
+                1, 'POLYGON((1 1, 2 1, 2 2, 1 2, 1 1))', 'POINT(1.5 1.5)',
+                [0.5, 0.6], datetime.datetime(1950, 1, 2, 12, 13, 14),
+                datetime.date(1950, 1, 2), datetime.time(12, 13, 14),
+                datetime.timedelta(seconds=123456), key,
+            ),
+            (
+                2, 'POLYGON((5 1, 6 1, 6 2, 5 2, 5 1))', 'POINT(5.5 1.5)',
+                [1.3, 2.5], datetime.datetime(1960, 3, 4, 15, 16, 17),
+                datetime.date(1960, 3, 4), datetime.time(15, 16, 17),
+                datetime.timedelta(seconds=2), key,
+            ),
+            (
+                3, 'POLYGON((5 5, 6 5, 6 6, 5 6, 5 5))', 'POINT(5.5 5.5)',
+                [10.3, 11.1], datetime.datetime(1970, 6, 7, 18, 19, 20),
+                datetime.date(1970, 5, 6), datetime.time(18, 19, 20),
+                datetime.timedelta(seconds=-2), key,
+            ),
+            (
+                4, 'POLYGON((1 5, 2 5, 2 6, 1 6, 1 5))', 'POINT(1.5 5.5)',
+                [3.3, 3.4], datetime.datetime(1980, 8, 9, 21, 22, 23),
+                datetime.date(1980, 7, 8), datetime.time(21, 22, 23),
+                datetime.timedelta(seconds=-123456), key,
+            ),
+            (
+                5, 'POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))', 'POINT(3.5 3.5)',
+                [2.9, 9.5], datetime.datetime(2010, 10, 11, 1, 2, 3),
+                datetime.date(2010, 8, 9), datetime.time(1, 2, 3),
+                datetime.timedelta(seconds=0), key,
+            ),
+        ]
+
+        new_data = []
+        for i, row in enumerate(data):
+            row = list(row)
+            row[1] = shapely.wkt.loads(row[1])
+            row[2] = shapely.wkt.loads(row[2])
+            if 'http' in self.conn.driver:
+                row[3] = ''
+            else:
+                row[3] = np.array(row[3], dtype='<f4')
+            new_data.append(row)
+
+        self.cur.executemany(
+            'INSERT INTO extended_types '
+            '(id, geography, geographypoint, vectors, dt, d, t, td, testkey) '
+            'VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)', new_data,
+        )
+
+        self.cur.execute(
+            'SELECT * FROM extended_types WHERE testkey = %s ORDER BY id', [key],
+        )
+
+        for data_row, row in zip(new_data, self.cur):
+            assert data_row[0] == row[0]
+            assert data_row[1].equals_exact(shapely.wkt.loads(row[1]), 1e-4)
+            assert data_row[2].equals_exact(shapely.wkt.loads(row[2]), 1e-4)
+            if 'http' in self.conn.driver:
+                assert row[3] == b''
+            else:
+                assert (data_row[3] == np.frombuffer(row[3], dtype='<f4')).all()
+
+        # pygeos data
+        data = [
+            (
+                6, 'POLYGON((1 1, 2 1, 2 2, 1 2, 1 1))', 'POINT(1.5 1.5)',
+                [0.5, 0.6], datetime.datetime(1950, 1, 2, 12, 13, 14),
+                datetime.date(1950, 1, 2), datetime.time(12, 13, 14),
+                datetime.timedelta(seconds=123456), key,
+            ),
+            (
+                7, 'POLYGON((5 1, 6 1, 6 2, 5 2, 5 1))', 'POINT(5.5 1.5)',
+                [1.3, 2.5], datetime.datetime(1960, 3, 4, 15, 16, 17),
+                datetime.date(1960, 3, 4), datetime.time(15, 16, 17),
+                datetime.timedelta(seconds=2), key,
+            ),
+            (
+                8, 'POLYGON((5 5, 6 5, 6 6, 5 6, 5 5))', 'POINT(5.5 5.5)',
+                [10.3, 11.1], datetime.datetime(1970, 6, 7, 18, 19, 20),
+                datetime.date(1970, 5, 6), datetime.time(18, 19, 20),
+                datetime.timedelta(seconds=-2), key,
+            ),
+            (
+                9, 'POLYGON((1 5, 2 5, 2 6, 1 6, 1 5))', 'POINT(1.5 5.5)',
+                [3.3, 3.4], datetime.datetime(1980, 8, 9, 21, 22, 23),
+                datetime.date(1980, 7, 8), datetime.time(21, 22, 23),
+                datetime.timedelta(seconds=-123456), key,
+            ),
+            (
+                10, 'POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))', 'POINT(3.5 3.5)',
+                [2.9, 9.5], datetime.datetime(2010, 10, 11, 1, 2, 3),
+                datetime.date(2010, 8, 9), datetime.time(1, 2, 3),
+                datetime.timedelta(seconds=0), key,
+            ),
+        ]
+
+        new_data = []
+        for i, row in enumerate(data):
+            row = list(row)
+            row[1] = pygeos.io.from_wkt(row[1])
+            row[2] = pygeos.io.from_wkt(row[2])
+            if 'http' in self.conn.driver:
+                row[3] = ''
+            else:
+                row[3] = np.array(row[3], dtype='<f4')
+            new_data.append(row)
+
+        self.cur.executemany(
+            'INSERT INTO extended_types '
+            '(id, geography, geographypoint, vectors, dt, d, t, td, testkey) '
+            'VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)', new_data,
+        )
+
+        self.cur.execute(
+            'SELECT * FROM extended_types WHERE id >= 6 and testkey = %s ORDER BY id', [
+                key,
+            ],
+        )
+
+        for data_row, row in zip(new_data, self.cur):
+            assert data_row[0] == row[0]
+            assert_geometries_equal(data_row[1], pygeos.io.from_wkt(row[1]))
+            assert_geometries_equal(data_row[2], pygeos.io.from_wkt(row[2]))
+            if 'http' in self.conn.driver:
+                assert row[3] == b''
+            else:
+                assert (data_row[3] == np.frombuffer(row[3], dtype='<f4')).all()
+
     def test_alltypes(self):
         self.cur.execute('select * from alltypes where id = 0')
         names = [x[0] for x in self.cur.description]
@@ -498,30 +650,8 @@ class TestBasics(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']
@@ -577,21 +707,12 @@ class TestBasics(unittest.TestCase):
         assert row['date'] == datetime.date(8524, 11, 10), row['date']
         assert typ['date'] == 10, typ['date']
 
-        # pyodbc uses time rather than timedelta. In addition, if you try to
-        # put your own converter in, it changes the type code to 15!!!
-        if self.driver == 'pyodbc':
-            assert row['time'] == datetime.time(0, 7, 0), row['time']
-        else:
-            assert row['time'] == datetime.timedelta(minutes=7), row['time']
+        assert row['time'] == datetime.timedelta(minutes=7), row['time']
         assert typ['time'] == 11, typ['time']
 
-        # Same as above
-        if self.driver == 'pyodbc':
-            assert row['time_6'] == datetime.time(0, 7, 0), row['time_6']
-        else:
-            assert row['time_6'] == datetime.timedelta(
-                hours=1, minutes=10, microseconds=2,
-            ), row['time_6']
+        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(
@@ -655,11 +776,7 @@ class TestBasics(unittest.TestCase):
         assert row['tinyblob'] == bytearray([10, 11, 12, 13, 14, 15]), 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']
@@ -669,11 +786,7 @@ class TestBasics(unittest.TestCase):
         assert row['set'] in [{'two'}, 'two'], row['set']
         assert typ['set'] == otype(253), typ['set']  # mysql code: 248
 
-        # pyodbc uses the opposite endianness of all other drivers
-        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):
@@ -684,30 +797,8 @@ class TestBasics(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']
@@ -832,6 +923,280 @@ class TestBasics(unittest.TestCase):
         assert row['bit'] is None, row['bit']
         assert typ['bit'] == otype(16), typ['bit']
 
+    def test_alltypes_mins(self):
+        self.cur.execute('select * from alltypes where id = 2')
+        names = [x[0] for x in self.cur.description]
+        out = self.cur.fetchone()
+        row = dict(zip(names, out))
+
+        expected = dict(
+            id=2,
+            tinyint=-128,
+            unsigned_tinyint=0,
+            bool=-128,
+            boolean=-128,
+            smallint=-32768,
+            unsigned_smallint=0,
+            mediumint=-8388608,
+            unsigned_mediumint=0,
+            int24=-8388608,
+            unsigned_int24=0,
+            int=-2147483648,
+            unsigned_int=0,
+            integer=-2147483648,
+            unsigned_integer=0,
+            bigint=-9223372036854775808,
+            unsigned_bigint=0,
+            float=0,
+            double=-1.7976931348623158e308,
+            real=-1.7976931348623158e308,
+            decimal=decimal.Decimal('-99999999999999.999999'),
+            dec=-decimal.Decimal('99999999999999.999999'),
+            fixed=decimal.Decimal('-99999999999999.999999'),
+            numeric=decimal.Decimal('-99999999999999.999999'),
+            date=datetime.date(1000, 1, 1),
+            time=-1 * datetime.timedelta(hours=838, minutes=59, seconds=59),
+            time_6=-1 * datetime.timedelta(hours=838, minutes=59, seconds=59),
+            datetime=datetime.datetime(1000, 1, 1, 0, 0, 0),
+            datetime_6=datetime.datetime(1000, 1, 1, 0, 0, 0, 0),
+            timestamp=datetime.datetime(1970, 1, 1, 0, 0, 1),
+            timestamp_6=datetime.datetime(1970, 1, 1, 0, 0, 1, 0),
+            year=1901,
+            char_100='',
+            binary_100=b'\x00' * 100,
+            varchar_200='',
+            varbinary_200=b'',
+            longtext='',
+            mediumtext='',
+            text='',
+            tinytext='',
+            longblob=b'',
+            mediumblob=b'',
+            blob=b'',
+            tinyblob=b'',
+            json={},
+            enum='one',
+            set='two',
+            bit=b'\x00\x00\x00\x00\x00\x00\x00\x00',
+        )
+
+        for k, v in sorted(row.items()):
+            assert v == expected[k], '{} != {} in key {}'.format(v, expected[k], k)
+
+    def test_alltypes_maxs(self):
+        self.cur.execute('select * from alltypes where id = 3')
+        names = [x[0] for x in self.cur.description]
+        out = self.cur.fetchone()
+        row = dict(zip(names, out))
+
+        expected = dict(
+            id=3,
+            tinyint=127,
+            unsigned_tinyint=255,
+            bool=127,
+            boolean=127,
+            smallint=32767,
+            unsigned_smallint=65535,
+            mediumint=8388607,
+            unsigned_mediumint=16777215,
+            int24=8388607,
+            unsigned_int24=16777215,
+            int=2147483647,
+            unsigned_int=4294967295,
+            integer=2147483647,
+            unsigned_integer=4294967295,
+            bigint=9223372036854775807,
+            unsigned_bigint=18446744073709551615,
+            float=0,
+            double=1.7976931348623158e308,
+            real=1.7976931348623158e308,
+            decimal=decimal.Decimal('99999999999999.999999'),
+            dec=decimal.Decimal('99999999999999.999999'),
+            fixed=decimal.Decimal('99999999999999.999999'),
+            numeric=decimal.Decimal('99999999999999.999999'),
+            date=datetime.date(9999, 12, 31),
+            time=datetime.timedelta(hours=838, minutes=59, seconds=59),
+            time_6=datetime.timedelta(hours=838, minutes=59, seconds=59),
+            datetime=datetime.datetime(9999, 12, 31, 23, 59, 59),
+            datetime_6=datetime.datetime(9999, 12, 31, 23, 59, 59, 999999),
+            timestamp=datetime.datetime(2038, 1, 19, 3, 14, 7),
+            timestamp_6=datetime.datetime(2038, 1, 19, 3, 14, 7, 999999),
+            year=2155,
+            char_100='',
+            binary_100=b'\x00' * 100,
+            varchar_200='',
+            varbinary_200=b'',
+            longtext='',
+            mediumtext='',
+            text='',
+            tinytext='',
+            longblob=b'',
+            mediumblob=b'',
+            blob=b'',
+            tinyblob=b'',
+            json={},
+            enum='one',
+            set='two',
+            bit=b'\xff\xff\xff\xff\xff\xff\xff\xff',
+        )
+
+        for k, v in sorted(row.items()):
+            # TODO: Figure out how to get time zones working
+            if 'timestamp' in k:
+                continue
+            assert v == expected[k], '{} != {} in key {}'.format(v, expected[k], k)
+
+    def test_alltypes_zeros(self):
+        self.cur.execute('select * from alltypes where id = 4')
+        names = [x[0] for x in self.cur.description]
+        out = self.cur.fetchone()
+        row = dict(zip(names, out))
+
+        expected = dict(
+            id=4,
+            tinyint=0,
+            unsigned_tinyint=0,
+            bool=0,
+            boolean=0,
+            smallint=0,
+            unsigned_smallint=0,
+            mediumint=0,
+            unsigned_mediumint=0,
+            int24=0,
+            unsigned_int24=0,
+            int=0,
+            unsigned_int=0,
+            integer=0,
+            unsigned_integer=0,
+            bigint=0,
+            unsigned_bigint=0,
+            float=0,
+            double=0,
+            real=0,
+            decimal=decimal.Decimal('0.0'),
+            dec=decimal.Decimal('0.0'),
+            fixed=decimal.Decimal('0.0'),
+            numeric=decimal.Decimal('0.0'),
+            date=None,
+            time=datetime.timedelta(hours=0, minutes=0, seconds=0),
+            time_6=datetime.timedelta(hours=0, minutes=0, seconds=0, microseconds=0),
+            datetime=None,
+            datetime_6=None,
+            timestamp=None,
+            timestamp_6=None,
+            year=None,
+            char_100='',
+            binary_100=b'\x00' * 100,
+            varchar_200='',
+            varbinary_200=b'',
+            longtext='',
+            mediumtext='',
+            text='',
+            tinytext='',
+            longblob=b'',
+            mediumblob=b'',
+            blob=b'',
+            tinyblob=b'',
+            json={},
+            enum='one',
+            set='two',
+            bit=b'\x00\x00\x00\x00\x00\x00\x00\x00',
+        )
+
+        for k, v in sorted(row.items()):
+            assert v == expected[k], '{} != {} in key {}'.format(v, expected[k], k)
+
+    def _test_MySQLdb(self):
+        try:
+            import json
+            import MySQLdb
+        except (ModuleNotFoundError, ImportError):
+            self.skipTest('MySQLdb is not installed')
+
+        self.cur.execute('select * from alltypes order by id')
+        s2_out = self.cur.fetchall()
+
+        port = self.conn.connection_params['port']
+        if 'http' in self.conn.driver:
+            port = 3306
+
+        args = dict(
+            host=self.conn.connection_params['host'],
+            port=port,
+            user=self.conn.connection_params['user'],
+            password=self.conn.connection_params['password'],
+            database=type(self).dbname,
+        )
+
+        with MySQLdb.connect(**args) as conn:
+            conn.converter[245] = json.loads
+            with conn.cursor() as cur:
+                cur.execute('select * from alltypes order by id')
+                mydb_out = cur.fetchall()
+
+        for a, b in zip(s2_out, mydb_out):
+            assert a == b, (a, b)
+
+    def test_int_string(self):
+        string = 'a' * 48
+        self.cur.execute(f"SELECT 1, '{string}'")
+        self.assertEqual((1, string), self.cur.fetchone())
+
+    def test_double_string(self):
+        string = 'a' * 49
+        self.cur.execute(f"SELECT 1.2 :> DOUBLE, '{string}'")
+        self.assertEqual((1.2, string), self.cur.fetchone())
+
+    def test_year_string(self):
+        string = 'a' * 49
+        self.cur.execute(f"SELECT 1999 :> YEAR, '{string}'")
+        self.assertEqual((1999, string), self.cur.fetchone())
+
+    def test_nan_as_null(self):
+        with self.assertRaises((s2.ProgrammingError, InvalidJSONError)):
+            self.cur.execute('SELECT %s :> DOUBLE AS X', [math.nan])
+
+        with s2.connect(database=type(self).dbname, nan_as_null=True) as conn:
+            with conn.cursor() as cur:
+                cur.execute('SELECT %s :> DOUBLE AS X', [math.nan])
+                self.assertEqual(None, list(cur)[0][0])
+
+        with s2.connect(database=type(self).dbname, nan_as_null=True) as conn:
+            with conn.cursor() as cur:
+                cur.execute('SELECT %s :> DOUBLE AS X', [1.234])
+                self.assertEqual(1.234, list(cur)[0][0])
+
+    def test_inf_as_null(self):
+        with self.assertRaises((s2.ProgrammingError, InvalidJSONError)):
+            self.cur.execute('SELECT %s :> DOUBLE AS X', [math.inf])
+
+        with s2.connect(database=type(self).dbname, inf_as_null=True) as conn:
+            with conn.cursor() as cur:
+                cur.execute('SELECT %s :> DOUBLE AS X', [math.inf])
+                self.assertEqual(None, list(cur)[0][0])
+
+        with s2.connect(database=type(self).dbname, inf_as_null=True) as conn:
+            with conn.cursor() as cur:
+                cur.execute('SELECT %s :> DOUBLE AS X', [1.234])
+                self.assertEqual(1.234, list(cur)[0][0])
+
+    def test_encoding_errors(self):
+        with s2.connect(
+            database=type(self).dbname,
+            encoding_errors='strict',
+        ) as conn:
+            with conn.cursor() as cur:
+                cur.execute('SELECT * FROM badutf8')
+                list(cur)
+
+        with s2.connect(
+            database=type(self).dbname,
+            encoding_errors='backslashreplace',
+        ) as conn:
+            with conn.cursor() as cur:
+                cur.execute('SELECT * FROM badutf8')
+                list(cur)
+
 
 if __name__ == '__main__':
     import nose2