singlestoredb 1.16.1__py3-none-any.whl

singlestoredb/mysql/tests/conftest.py

@@ -0,0 +1,37 @@
+import platform
+
+import singlestoredb.mysql as sv
+from singlestoredb.connection import build_params
+
+
+DBNAME_BASE = 'singlestoredb__test_%s_%s_%s_%s_' % \
+              (
+                  *platform.python_version_tuple()[:2],
+                  platform.system(), platform.machine(),
+              )
+
+
+def pytest_sessionstart() -> None:
+    params = build_params()
+    conn = sv.connect(  # type: ignore
+        host=params['host'], user=params['user'],
+        passwd=params['password'], port=params['port'],
+        buffered=params['buffered'],
+    )
+    cur = conn.cursor()
+    cur.execute(f'CREATE DATABASE IF NOT EXISTS {DBNAME_BASE}1')
+    cur.execute(f'CREATE DATABASE IF NOT EXISTS {DBNAME_BASE}2')
+    conn.close()
+
+
+def pytest_sessionfinish() -> None:
+    params = build_params()
+    conn = sv.connect(  # type: ignore
+        host=params['host'], user=params['user'],
+        passwd=params['password'], port=params['port'],
+        buffered=params['buffered'],
+    )
+    cur = conn.cursor()
+    cur.execute(f'DROP DATABASE {DBNAME_BASE}1')
+    cur.execute(f'DROP DATABASE {DBNAME_BASE}2')
+    conn.close()

singlestoredb/mysql/tests/test_DictCursor.py

@@ -0,0 +1,132 @@
+# type: ignore
+import datetime
+import warnings
+
+import pytest
+
+import singlestoredb.mysql.cursors as cursors
+from singlestoredb.mysql.tests import base
+
+
+class TestDictCursor(base.PyMySQLTestCase):
+
+    bob = {'name': 'bob', 'age': 21, 'DOB': datetime.datetime(1990, 2, 6, 23, 4, 56)}
+    jim = {'name': 'jim', 'age': 56, 'DOB': datetime.datetime(1955, 5, 9, 13, 12, 45)}
+    fred = {'name': 'fred', 'age': 100, 'DOB': datetime.datetime(1911, 9, 12, 1, 1, 1)}
+
+    cursor_type = cursors.DictCursor
+
+    def setUp(self):
+        super(TestDictCursor, self).setUp()
+        self.conn = conn = self.connect(cursorclass=self.cursor_type)
+        c = conn.cursor()
+
+        # create a table ane some data to query
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore')
+            c.execute('drop table if exists dictcursor')
+            # include in filterwarnings since for unbuffered dict cursor warning
+            # for lack of table will only be propagated at start of next execute() call
+            c.execute(
+                """CREATE TABLE dictcursor (name char(20), age int , DOB datetime)""",
+            )
+        data = [
+            ('bob', 21, '1990-02-06 23:04:56'),
+            ('jim', 56, '1955-05-09 13:12:45'),
+            ('fred', 100, '1911-09-12 01:01:01'),
+        ]
+        c.executemany('insert into dictcursor values (%s,%s,%s)', data)
+
+    def tearDown(self):
+        c = self.conn.cursor()
+        c.execute('drop table dictcursor')
+        super(TestDictCursor, self).tearDown()
+
+    def _ensure_cursor_expired(self, cursor):
+        pass
+
+    def test_DictCursor(self):
+        bob, jim, fred = self.bob.copy(), self.jim.copy(), self.fred.copy()
+        # all assert test compare to the structure as would come out from MySQLdb
+        conn = self.conn
+        c = conn.cursor()
+
+        # try an update which should return no rows
+        c.execute("update dictcursor set age=20 where name='bob'")
+        bob['age'] = 20
+        # pull back the single row dict for bob and check
+        c.execute("SELECT * from dictcursor where name='bob'")
+        r = c.fetchone()
+        self.assertEqual(bob, r, 'fetchone via DictCursor failed')
+        self._ensure_cursor_expired(c)
+
+        # same again, but via fetchall => tuple)
+        c.execute("SELECT * from dictcursor where name='bob'")
+        r = c.fetchall()
+        self.assertEqual(
+            [bob], r, 'fetch a 1 row result via fetchall failed via DictCursor',
+        )
+        # same test again but iterate over the
+        c.execute("SELECT * from dictcursor where name='bob'")
+        for r in c:
+            self.assertEqual(
+                bob, r, 'fetch a 1 row result via iteration failed via DictCursor',
+            )
+        # get all 3 row via fetchall
+        c.execute('SELECT * from dictcursor ORDER BY name')
+        r = c.fetchall()
+        self.assertEqual([bob, fred, jim], r, 'fetchall failed via DictCursor')
+        # same test again but do a list comprehension
+        c.execute('SELECT * from dictcursor ORDER BY name')
+        r = list(c)
+        self.assertEqual([bob, fred, jim], r, 'DictCursor should be iterable')
+        # get all 2 row via fetchmany
+        c.execute('SELECT * from dictcursor ORDER BY name')
+        r = c.fetchmany(2)
+        self.assertEqual([bob, fred], r, 'fetchmany failed via DictCursor')
+        self._ensure_cursor_expired(c)
+
+    @pytest.mark.skip('Custom cursors are only available when creating a connection')
+    def test_custom_dict(self):
+        class MyDict(dict):
+            pass
+
+        class MyDictCursor(self.cursor_type):
+            dict_type = MyDict
+
+        keys = ['name', 'age', 'DOB']
+        bob = MyDict([(k, self.bob[k]) for k in keys])
+        jim = MyDict([(k, self.jim[k]) for k in keys])
+        fred = MyDict([(k, self.fred[k]) for k in keys])
+
+        cur = self.conn.cursor(MyDictCursor)
+        cur.execute("SELECT * FROM dictcursor WHERE name='bob'")
+        r = cur.fetchone()
+        self.assertEqual(bob, r, 'fetchone() returns MyDictCursor')
+        self._ensure_cursor_expired(cur)
+
+        cur.execute('SELECT * FROM dictcursor ORDER BY name')
+        r = cur.fetchall()
+        self.assertEqual([bob, fred, jim], r, 'fetchall failed via MyDictCursor')
+
+        cur.execute('SELECT * FROM dictcursor ORDER BY name')
+        r = list(cur)
+        self.assertEqual([bob, fred, jim], r, 'list failed via MyDictCursor')
+
+        cur.execute('SELECT * FROM dictcursor ORDER BY name')
+        r = cur.fetchmany(2)
+        self.assertEqual([bob, fred], r, 'list failed via MyDictCursor')
+        self._ensure_cursor_expired(cur)
+
+
+class TestSSDictCursor(TestDictCursor):
+    cursor_type = cursors.SSDictCursor
+
+    def _ensure_cursor_expired(self, cursor):
+        list(cursor.fetchall_unbuffered())
+
+
+if __name__ == '__main__':
+    import unittest
+
+    unittest.main()

singlestoredb/mysql/tests/test_SSCursor.py

@@ -0,0 +1,141 @@
+# type: ignore
+import sys
+
+try:
+    import singlestoredb.mysql as sv
+    from singlestoredb.mysql.tests import base
+    import singlestoredb.mysql.cursors as cursors
+    from singlestoredb.mysql.constants import CLIENT
+except Exception:
+    # For local testing from top-level directory, without installing
+    sys.path.append('../../..')
+    import singlestoredb.mysql as sv  # noqa: F401
+    from singlestoredb.mysql.tests import base
+    import singlestoredb.mysql.cursors as cursors
+    from singlestoredb.mysql.constants import CLIENT
+
+
+class TestSSCursor(base.PyMySQLTestCase):
+
+    def test_SSCursor(self):
+        # affected_rows = 18446744073709551615
+        affected_rows = -1
+
+        conn = self.connect(
+            client_flag=CLIENT.MULTI_STATEMENTS,
+            cursorclass=cursors.SSCursor,
+        )
+        data = [
+            ('America', '', 'America/Jamaica'),
+            ('America', '', 'America/Los_Angeles'),
+            ('America', '', 'America/Lima'),
+            ('America', '', 'America/New_York'),
+            ('America', '', 'America/Menominee'),
+            ('America', '', 'America/Havana'),
+            ('America', '', 'America/El_Salvador'),
+            ('America', '', 'America/Costa_Rica'),
+            ('America', '', 'America/Denver'),
+            ('America', '', 'America/Detroit'),
+        ]
+
+        cursor = conn.cursor()
+
+        cursor.execute('DROP TABLE IF EXISTS tz_data')
+
+        # Create table
+        cursor.execute(
+            'CREATE TABLE tz_data ('
+            'region VARCHAR(64),'
+            'zone VARCHAR(64),'
+            'name VARCHAR(64))',
+        )
+
+        conn.begin()
+        # Test INSERT
+        for i in data:
+            cursor.execute('INSERT INTO tz_data VALUES (%s, %s, %s)', i)
+            self.assertEqual(conn.affected_rows(), 1, 'affected_rows does not match')
+        conn.commit()
+
+        # Test fetchone()
+        iter = 0
+        cursor.execute('SELECT * FROM tz_data')
+        while True:
+            row = cursor.fetchone()
+            if row is None:
+                break
+            iter += 1
+
+            # Test cursor.rowcount
+            self.assertEqual(
+                cursor.rowcount,
+                affected_rows,
+                'cursor.rowcount != %s' % (str(affected_rows)),
+            )
+
+            # Test cursor.rownumber
+            self.assertEqual(
+                cursor.rownumber, iter, 'cursor.rowcount != %s' % (str(iter)),
+            )
+
+            # Test row came out the same as it went in
+            self.assertEqual((row in data), True, 'Row not found in source data')
+
+        # Test fetchall
+        cursor.execute('SELECT * FROM tz_data')
+        self.assertEqual(
+            len(cursor.fetchall()),
+            len(data),
+            'fetchall failed. Number of rows does not match',
+        )
+
+        # Test fetchmany
+        cursor.execute('SELECT * FROM tz_data')
+        self.assertEqual(
+            len(cursor.fetchmany(2)),
+            2,
+            'fetchmany failed. Number of rows does not match',
+        )
+
+        # So MySQLdb won't throw "Commands out of sync"
+        while True:
+            res = cursor.fetchone()
+            if res is None:
+                break
+
+        # Test update, affected_rows()
+        cursor.execute('UPDATE tz_data SET zone = %s', ['Foo'])
+        conn.commit()
+        self.assertEqual(
+            cursor.rowcount,
+            len(data),
+            'Update failed. affected_rows != %s' % (str(len(data))),
+        )
+
+        # Test executemany
+        cursor.executemany('INSERT INTO tz_data VALUES (%s, %s, %s)', data)
+        self.assertEqual(
+            cursor.rowcount,
+            len(data),
+            'executemany failed. cursor.rowcount != %s' % (str(len(data))),
+        )
+
+        # Test multiple datasets
+        cursor.execute('SELECT 1; SELECT 2; SELECT 3')
+        self.assertListEqual(list(cursor), [(1,)])
+        self.assertTrue(cursor.nextset())
+        self.assertListEqual(list(cursor), [(2,)])
+        self.assertTrue(cursor.nextset())
+        self.assertListEqual(list(cursor), [(3,)])
+        self.assertFalse(cursor.nextset())
+
+        cursor.execute('DROP TABLE IF EXISTS tz_data')
+        cursor.close()
+
+
+__all__ = ['TestSSCursor']
+
+if __name__ == '__main__':
+    import unittest
+
+    unittest.main()