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

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

@@ -0,0 +1,110 @@
+# type: ignore
+import warnings
+
+import singlestoredb.mysql as sv
+from . import capabilities
+from singlestoredb.mysql.tests import base
+
+warnings.filterwarnings('error')
+
+
+class test_MySQLdb(capabilities.DatabaseTest):
+
+    db_module = sv
+    connect_args = ()
+    connect_kwargs = base.PyMySQLTestCase.databases[0].copy()
+    connect_kwargs.update(
+        dict(
+            read_default_file='~/.my.cnf',
+            use_unicode=True,
+            binary_prefix=True,
+            charset='utf8mb4',
+            sql_mode='ANSI,STRICT_TRANS_TABLES,TRADITIONAL',
+        ),
+    )
+
+    leak_test = False
+
+    def quote_identifier(self, ident):
+        return '`%s`' % ident
+
+    def test_TIME(self):
+        from datetime import timedelta
+
+        def generator(row, col):
+            return timedelta(0, row * 8000)
+
+        self.check_data_integrity(('col1 TIME',), generator)
+
+    def test_TINYINT(self):
+        # Number data
+        def generator(row, col):
+            v = (row * row) % 256
+            if v > 127:
+                v = v - 256
+            return v
+
+        self.check_data_integrity(('col1 TINYINT',), generator)
+
+    def test_stored_procedures(self):
+        db = self.connection
+        c = self.cursor
+        try:
+            self.create_table(('pos INT', 'tree CHAR(20)'))
+            c.executemany(
+                'INSERT INTO %s (pos,tree) VALUES (%%s,%%s)' % self.table,
+                list(enumerate('ash birch cedar larch pine'.split())),
+            )
+            db.commit()
+
+            c.execute(
+                """
+            CREATE PROCEDURE test_sp(t VARCHAR(255)) AS
+            BEGIN
+                ECHO SELECT pos FROM %s WHERE tree = t;
+            END
+            """
+                % self.table,
+            )
+            db.commit()
+
+            c.callproc('test_sp', ('larch',))
+            rows = c.fetchall()
+            self.assertEqual(len(rows), 1)
+            self.assertEqual(rows[0][0], 3)
+            c.nextset()
+        finally:
+            c.execute('DROP PROCEDURE IF EXISTS test_sp')
+            c.execute('drop table %s' % (self.table))
+
+    def test_small_CHAR(self):
+        # Character data
+        def generator(row, col):
+            i = ((row + 1) * (col + 1) + 62) % 256
+            if i == 62:
+                return ''
+            if i == 63:
+                return None
+            return chr(i)
+
+        self.check_data_integrity(('col1 char(1)', 'col2 char(1)'), generator)
+
+    def test_bug_2671682(self):
+        from singlestoredb.mysql.constants import ER
+
+        try:
+            self.cursor.execute('describe some_non_existent_table')
+        except self.connection.ProgrammingError as msg:
+            self.assertEqual(msg.args[0], ER.NO_SUCH_TABLE)
+
+    def test_ping(self):
+        self.connection.ping()
+
+    def test_literal_int(self):
+        self.assertTrue('2' == self.connection.literal(2))
+
+    def test_literal_float(self):
+        self.assertEqual('3.1415e0', self.connection.literal(3.1415))
+
+    def test_literal_string(self):
+        self.assertTrue("'foo'" == self.connection.literal('foo'))

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

@@ -0,0 +1,224 @@
+# type: ignore
+import singlestoredb.mysql as sv
+from . import dbapi20
+from singlestoredb.mysql.tests import base
+
+
+class test_MySQLdb(dbapi20.DatabaseAPI20Test):
+
+    driver = sv
+    connect_args = ()
+    connect_kw_args = base.PyMySQLTestCase.databases[0].copy()
+    connect_kw_args.update(
+        dict(
+            read_default_file='~/.my.cnf',
+            charset='utf8',
+            sql_mode='ANSI,STRICT_TRANS_TABLES,TRADITIONAL',
+        ),
+    )
+
+    def test_setoutputsize(self):
+        pass
+
+    def test_setoutputsize_basic(self):
+        pass
+
+    # The tests on fetchone and fetchall and rowcount bogusly
+    # test for an exception if the statement cannot return a
+    # result set. MySQL always returns a result set; it's just that
+    # some things return empty result sets.
+
+    def test_fetchall(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            # cursor.fetchall should raise an Error if called
+            # without executing a query that may return rows (such
+            # as a select)
+            self.assertRaises(self.driver.Error, cur.fetchall)
+
+            self.executeDDL1(cur)
+            for sql in self._populate():
+                cur.execute(sql)
+
+            # cursor.fetchall should raise an Error if called
+            # after executing a a statement that cannot return rows
+            # self.assertRaises(self.driver.Error,cur.fetchall)
+
+            cur.execute('select name from %sbooze' % self.table_prefix)
+            rows = cur.fetchall()
+            self.assertTrue(cur.rowcount in (-1, len(self.samples)))
+            self.assertEqual(
+                len(rows),
+                len(self.samples),
+                'cursor.fetchall did not retrieve all rows',
+            )
+            rows = [r[0] for r in rows]
+            rows.sort()
+            for i in range(0, len(self.samples)):
+                self.assertEqual(
+                    rows[i], self.samples[i], 'cursor.fetchall retrieved incorrect rows',
+                )
+            rows = cur.fetchall()
+            self.assertEqual(
+                len(rows),
+                0,
+                'cursor.fetchall should return an empty list if called '
+                'after the whole result set has been fetched',
+            )
+            self.assertTrue(cur.rowcount in (-1, len(self.samples)))
+
+            self.executeDDL2(cur)
+            cur.execute('select name from %sbarflys' % self.table_prefix)
+            rows = cur.fetchall()
+            self.assertTrue(cur.rowcount in (-1, 0))
+            self.assertEqual(
+                len(rows),
+                0,
+                'cursor.fetchall should return an empty list if '
+                'a select query returns no rows',
+            )
+
+        finally:
+            con.close()
+
+    def test_fetchone(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+
+            # cursor.fetchone should raise an Error if called before
+            # executing a select-type query
+            self.assertRaises(self.driver.Error, cur.fetchone)
+
+            # cursor.fetchone should raise an Error if called after
+            # executing a query that cannnot return rows
+            self.executeDDL1(cur)
+            # self.assertRaises(self.driver.Error,cur.fetchone)
+
+            cur.execute('select name from %sbooze' % self.table_prefix)
+            self.assertEqual(
+                cur.fetchone(),
+                None,
+                'cursor.fetchone should return None if a query retrieves ' 'no rows',
+            )
+            self.assertTrue(cur.rowcount in (-1, 0))
+
+            # cursor.fetchone should raise an Error if called after
+            # executing a query that cannnot return rows
+            cur.execute(
+                "insert into %sbooze values ('Victoria Bitter')" % (self.table_prefix),
+            )
+            # self.assertRaises(self.driver.Error,cur.fetchone)
+
+            cur.execute('select name from %sbooze' % self.table_prefix)
+            r = cur.fetchone()
+            self.assertEqual(
+                len(r), 1, 'cursor.fetchone should have retrieved a single row',
+            )
+            self.assertEqual(
+                r[0], 'Victoria Bitter', 'cursor.fetchone retrieved incorrect data',
+            )
+            # self.assertEqual(cur.fetchone(), None,
+            #                  'cursor.fetchone should return None if '
+            #                  'no more rows available'
+            # )
+            self.assertTrue(cur.rowcount in (-1, 1))
+        finally:
+            con.close()
+
+    # Same complaint as for fetchall and fetchone
+    def test_rowcount(self):
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            self.executeDDL1(cur)
+            # self.assertEqual(cur.rowcount,-1,
+            #                  'cursor.rowcount should be -1 after executing no-result '
+            # 'statements'
+            # )
+            cur.execute(
+                "insert into %sbooze values ('Victoria Bitter')" % (self.table_prefix),
+            )
+            # self.assertTrue(cur.rowcount in (-1,1),
+            #                  'cursor.rowcount should == number or rows inserted, or '
+            #                  'set to -1 after executing an insert statement'
+            # )
+            cur.execute('select name from %sbooze' % self.table_prefix)
+            self.assertTrue(
+                cur.rowcount in (-1, 1),
+                'cursor.rowcount should == number of rows returned, or '
+                'set to -1 after executing a select statement',
+            )
+            cur.fetchall()
+            self.executeDDL2(cur)
+        # self.assertEqual(cur.rowcount, -1,
+        #                  'cursor.rowcount not being reset to -1 after executing '
+        #                  'no-result statements'
+        # )
+        finally:
+            con.close()
+
+    def test_callproc(self):
+        pass  # performed in test_MySQL_capabilities
+
+    def help_nextset_setUp(self, cur):
+        """Should create a procedure called deleteme
+        that returns two result sets, first the
+        number of rows in booze then "name from booze"
+        """
+        sql = """
+           create procedure deleteme() as
+           begin
+               echo select count(*) from %(tp)sbooze;
+               echo select name from %(tp)sbooze;
+           end
+        """ % dict(
+            tp=self.table_prefix,
+        )
+        cur.execute(sql)
+
+    def help_nextset_tearDown(self, cur):
+        # If cleaning up is needed after nextSetTest
+        cur.execute('drop procedure deleteme')
+
+    def test_nextset(self):
+        # from warnings import warn
+
+        con = self._connect()
+        try:
+            cur = con.cursor()
+            if not hasattr(cur, 'nextset'):
+                return
+
+            try:
+                self.executeDDL1(cur)
+                sql = self._populate()
+                for sql in self._populate():
+                    cur.execute(sql)
+
+                self.help_nextset_setUp(cur)
+
+                cur.callproc('deleteme')
+                numberofrows = cur.fetchone()
+                assert numberofrows[0] == len(self.samples)
+                if cur._result.unbuffered_active:
+                    assert len(cur.fetchall()) == 0
+                assert cur.nextset()
+                names = cur.fetchall()
+                assert len(names) == len(self.samples)
+                s = cur.nextset()
+                if s:
+                    empty = cur.fetchall()
+                    self.assertEqual(
+                        len(empty), 0, 'non-empty result set after other result sets',
+                    )
+                    # warn("Incompatibility: MySQL returns an empty result set "
+                    #      "for the CALL itself",
+                    #      Warning)
+                # assert s == None,'No more return sets, should return None'
+            finally:
+                self.help_nextset_tearDown(cur)
+
+        finally:
+            con.close()

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

@@ -0,0 +1,101 @@
+# type: ignore
+import unittest
+
+import singlestoredb.mysql as sv
+from singlestoredb.mysql.constants import FIELD_TYPE
+from singlestoredb.mysql.tests import base
+
+_mysql = sv
+
+
+class TestDBAPISet(unittest.TestCase):
+
+    def test_set_equality(self):
+        self.assertTrue(sv.STRING == sv.STRING)
+
+    def test_set_inequality(self):
+        self.assertTrue(sv.STRING != sv.NUMBER)
+
+    def test_set_equality_membership(self):
+        self.assertTrue(FIELD_TYPE.VAR_STRING == sv.STRING)
+
+    def test_set_inequality_membership(self):
+        self.assertTrue(FIELD_TYPE.DATE != sv.STRING)
+
+
+class CoreModule(unittest.TestCase):
+    """Core _mysql module features."""
+
+    def test_NULL(self):
+        """Should have a NULL constant."""
+        self.assertEqual(_mysql.NULL, 'NULL')
+
+    def test_version(self):
+        """Version information sanity."""
+        self.assertTrue(isinstance(_mysql.__version__, str))
+
+        self.assertTrue(isinstance(_mysql.version_info, tuple))
+        self.assertEqual(len(_mysql.version_info), 5)
+
+    def test_client_info(self):
+        self.assertTrue(isinstance(_mysql.get_client_info(), str))
+
+    def test_thread_safe(self):
+        self.assertTrue(isinstance(_mysql.thread_safe(), int))
+
+
+class CoreAPI(unittest.TestCase):
+    """Test _mysql interaction internals."""
+
+    def setUp(self):
+        kwargs = base.PyMySQLTestCase.databases[0].copy()
+        kwargs['read_default_file'] = '~/.my.cnf'
+        self.conn = _mysql.connect(**kwargs)
+
+    def tearDown(self):
+        self.conn.close()
+
+    def test_thread_id(self):
+        tid = self.conn.thread_id()
+        self.assertTrue(
+            isinstance(tid, int), "thread_id didn't return an integral value.",
+        )
+
+        self.assertRaises(
+            TypeError,
+            self.conn.thread_id,
+            ('evil',),
+            "thread_id shouldn't accept arguments.",
+        )
+
+    def test_affected_rows(self):
+        self.assertEqual(
+            self.conn.affected_rows(), 0, 'Should return 0 before we do anything.',
+        )
+
+    # def test_debug(self):
+    # FIXME Only actually tests if you lack SUPER
+    # self.assertRaises(sv.OperationalError,
+    # self.conn.dump_debug_info)
+
+    def test_charset_name(self):
+        self.assertTrue(
+            isinstance(self.conn.character_set_name(), str), 'Should return a string.',
+        )
+
+    def test_host_info(self):
+        assert isinstance(self.conn.get_host_info(), str), 'should return a string'
+
+    def test_proto_info(self):
+        self.assertTrue(
+            isinstance(self.conn.get_proto_info(), int), 'Should return an int.',
+        )
+
+    def test_server_info(self):
+        self.assertTrue(
+            isinstance(self.conn.get_server_info(), str), 'Should return an str.',
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()

singlestoredb/mysql/times.py

@@ -0,0 +1,23 @@
+from datetime import date
+from datetime import datetime
+from datetime import time
+from datetime import timedelta
+from time import localtime
+
+
+Date = date
+Time = time
+TimeDelta = timedelta
+Timestamp = datetime
+
+
+def DateFromTicks(ticks: int) -> date:
+    return date(*localtime(ticks)[:3])
+
+
+def TimeFromTicks(ticks: int) -> time:
+    return time(*localtime(ticks)[3:6])
+
+
+def TimestampFromTicks(ticks: int) -> datetime:
+    return datetime(*localtime(ticks)[:6])