singlestoredb 1.16.1__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])

singlestoredb/notebook/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+import os as _os
+import warnings as _warnings
+
+from ._objects import organization  # noqa: F401
+from ._objects import secrets  # noqa: F401
+from ._objects import stage  # noqa: F401
+from ._objects import workspace  # noqa: F401
+from ._objects import workspace_group  # noqa: F401
+from ._portal import portal  # noqa: F401
+
+if 'SINGLESTOREDB_ORGANIZATION' not in _os.environ:
+    _warnings.warn(
+        'This package is intended for use in the SingleStoreDB notebook environment',
+        RuntimeWarning,
+    )

singlestoredb/notebook/_objects.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+import functools
+from typing import Any
+from typing import Optional
+
+from ..management import workspace as _ws
+
+
+class Secrets(object):
+    """Wrapper for accessing secrets as object attributes."""
+
+    def __getattr__(self, name: str) -> Optional[str]:
+        if name.startswith('_ipython') or name.startswith('_repr_'):
+            raise AttributeError(name)
+        return _ws.get_secret(name)
+
+    def __getitem__(self, name: str) -> Optional[str]:
+        return _ws.get_secret(name)
+
+
+class Stage(object):
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        # We are remapping the methods and attributes here so that
+        # autocomplete still works in Jupyter / IPython, but we
+        # bypass the real method / attribute calls and apply them
+        # to the currently selected stage.
+        for name in [x for x in dir(_ws.Stage) if not x.startswith('_')]:
+            if name in ['from_dict', 'refresh', 'update']:
+                continue
+            attr = getattr(_ws.Stage, name)
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                if is_method:
+                    def wrap(self: Stage, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_stage(), m)(*a, **kw)
+                    return functools.update_wrapper(wrap, attr)
+                else:
+                    def wrap(self: Stage, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_stage(), m)
+                    return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name, is_method=callable(attr)))
+
+        for name in [
+            x for x in _ws.Stage.__annotations__.keys()
+            if not x.startswith('_')
+        ]:
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                def wrap(self: Stage) -> Any:
+                    return getattr(_ws.get_stage(), m)
+                return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name))
+
+        cls.__doc__ = _ws.Stage.__doc__
+
+        return super().__new__(cls, *args, **kwargs)
+
+
+class WorkspaceGroup(object):
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        # We are remapping the methods and attributes here so that
+        # autocomplete still works in Jupyter / IPython, but we
+        # bypass the real method / attribute calls and apply them
+        # to the currently selected workspace group.
+        for name in [x for x in dir(_ws.WorkspaceGroup) if not x.startswith('_')]:
+            if name in ['from_dict', 'refresh', 'update']:
+                continue
+
+            attr = getattr(_ws.WorkspaceGroup, name)
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                if is_method:
+                    def wrap(self: WorkspaceGroup, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_workspace_group(), m)(*a, **kw)
+                    return functools.update_wrapper(wrap, attr)
+                else:
+                    def wrap(self: WorkspaceGroup, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_workspace_group(), m)
+                    return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name, is_method=callable(attr)))
+
+        for name in [
+            x for x in _ws.WorkspaceGroup.__annotations__.keys()
+            if not x.startswith('_')
+        ]:
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                def wrap(self: WorkspaceGroup) -> Any:
+                    return getattr(_ws.get_workspace_group(), m)
+                return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name))
+
+        cls.__doc__ = _ws.WorkspaceGroup.__doc__
+
+        return super().__new__(cls, *args, **kwargs)
+
+    def __str__(self) -> str:
+        return _ws.get_workspace_group().__str__()
+
+    def __repr__(self) -> str:
+        return _ws.get_workspace_group().__repr__()
+
+
+class Workspace(object):
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        # We are remapping the methods and attributes here so that
+        # autocomplete still works in Jupyter / IPython, but we
+        # bypass the real method / attribute calls and apply them
+        # to the currently selected workspace.
+        for name in [x for x in dir(_ws.Workspace) if not x.startswith('_')]:
+            if name in ['from_dict', 'refresh', 'update']:
+                continue
+
+            attr = getattr(_ws.Workspace, name)
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                if is_method:
+                    def wrap(self: Workspace, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_workspace(), m)(*a, **kw)
+                    return functools.update_wrapper(wrap, attr)
+                else:
+                    def wrap(self: Workspace, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_workspace(), m)
+                    return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name, is_method=callable(attr)))
+
+        for name in [
+            x for x in _ws.Workspace.__annotations__.keys()
+            if not x.startswith('_')
+        ]:
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                def wrap(self: Workspace) -> Any:
+                    return getattr(_ws.get_workspace(), m)
+                return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name))
+
+        cls.__doc__ = _ws.Workspace.__doc__
+
+        return super().__new__(cls, *args, **kwargs)
+
+    def __str__(self) -> str:
+        return _ws.get_workspace().__str__()
+
+    def __repr__(self) -> str:
+        return _ws.get_workspace().__repr__()
+
+
+class Organization(object):
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        # We are remapping the methods and attributes here so that
+        # autocomplete still works in Jupyter / IPython, but we
+        # bypass the real method / attribute calls and apply them
+        # to the currently selected organization.
+        for name in [x for x in dir(_ws.Organization) if not x.startswith('_')]:
+            if name in ['from_dict', 'refresh', 'update']:
+                continue
+
+            attr = getattr(_ws.Organization, name)
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                if is_method:
+                    def wrap(self: Organization, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_organization(), m)(*a, **kw)
+                    return functools.update_wrapper(wrap, attr)
+                else:
+                    def wrap(self: Organization, *a: Any, **kw: Any) -> Any:
+                        return getattr(_ws.get_organization(), m)
+                    return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name, is_method=callable(attr)))
+
+        for name in [
+            x for x in _ws.Organization.__annotations__.keys()
+            if not x.startswith('_')
+        ]:
+
+            def make_wrapper(m: str, is_method: bool = False) -> Any:
+                def wrap(self: Organization) -> Any:
+                    return getattr(_ws.get_organization(), m)
+                return property(functools.update_wrapper(wrap, attr))
+
+            setattr(cls, name, make_wrapper(m=name))
+
+        cls.__doc__ = _ws.Organization.__doc__
+
+        return super().__new__(cls, *args, **kwargs)
+
+    def __str__(self) -> str:
+        return _ws.get_organization().__str__()
+
+    def __repr__(self) -> str:
+        return _ws.get_organization().__repr__()
+
+
+secrets = Secrets()
+stage = Stage()
+organization = Organization()
+workspace_group = WorkspaceGroup()
+workspace = Workspace()
+
+
+__all__ = ['secrets', 'stage', 'workspace', 'workspace_group', 'organization']