singlestoredb 1.16.1__py3-none-any.whl

singlestoredb/tests/test_plugin.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+# type: ignore
+"""SingleStoreDB Pytest Plugin testing
+
+Each of these tests performs the same simple operation which
+would fail if any other test had been run on the same database.
+"""
+from singlestoredb.connection import Cursor
+
+# pytest_plugins = ('singlestoredb.pytest',)
+
+CREATE_TABLE_STATEMENT = 'create table test_dict (a text)'
+
+
+def test_tempdb1(singlestoredb_tempdb: Cursor):
+    # alias the fixture
+    cursor = singlestoredb_tempdb
+
+    cursor.execute(CREATE_TABLE_STATEMENT)
+
+
+def test_tempdb2(singlestoredb_tempdb: Cursor):
+    # alias the fixture
+    cursor = singlestoredb_tempdb
+
+    cursor.execute(CREATE_TABLE_STATEMENT)
+
+
+def test_tempdb3(singlestoredb_tempdb: Cursor):
+    # alias the fixture
+    cursor = singlestoredb_tempdb
+
+    cursor.execute(CREATE_TABLE_STATEMENT)

singlestoredb/tests/test_results.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+# type: ignore
+"""Test SingleStoreDB results."""
+import os
+import unittest
+
+import pandas as pd
+
+import singlestoredb as s2
+from singlestoredb.tests import utils
+# import traceback
+
+
+class TestResults(unittest.TestCase):
+
+    dbname: str = ''
+    dbexisted: bool = False
+
+    @classmethod
+    def setUpClass(cls):
+        sql_file = os.path.join(os.path.dirname(__file__), 'test.sql')
+        cls.dbname, cls.dbexisted = utils.load_sql(sql_file)
+
+    @classmethod
+    def tearDownClass(cls):
+        if not cls.dbexisted:
+            utils.drop_database(cls.dbname)
+
+    def setUp(self):
+        self.conn = s2.connect(database=type(self).dbname)
+        self.cur = self.conn.cursor()
+
+    def tearDown(self):
+        try:
+            if self.cur is not None:
+                self.cur.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+        try:
+            if self.conn is not None:
+                self.conn.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+    def test_tuples(self):
+        with s2.options(('results.type', 'tuples')):
+            with s2.connect(database=type(self).dbname) as conn:
+                with conn.cursor() as cur:
+                    cur.execute('select * from data')
+                    out = cur.fetchone()
+                    assert type(out) is tuple, type(out)
+                    assert len(out) == 3, len(out)
+                    cur.fetchall()
+
+                    cur.execute('select * from data')
+                    out = cur.fetchall()
+                    assert len(out) == 5, len(out)
+                    assert len(out[0]) == 3, len(out[0])
+                    assert type(out[0]) is tuple, type(out[0])
+                    assert sorted(out) == sorted([
+                        ('a', 'antelopes', 2),
+                        ('b', 'bears', 2),
+                        ('c', 'cats', 5),
+                        ('d', 'dogs', 4),
+                        ('e', 'elephants', 0),
+                    ]), out
+
+                    out = cur.fetchall()
+                    assert len(out) == 0, len(out)
+
+    def test_namedtuples(self):
+        with s2.options(('results.type', 'namedtuples')):
+            with s2.connect(database=type(self).dbname) as conn:
+                with conn.cursor() as cur:
+                    cur.execute('select * from data')
+                    out = cur.fetchone()
+                    assert isinstance(out, tuple), type(out)
+                    assert len(out) == 3, len(out)
+                    assert type(out).__name__ == 'Row', type(out).__name__
+                    assert hasattr(out, 'id')
+                    assert hasattr(out, 'name')
+                    assert hasattr(out, 'value')
+                    cur.fetchall()
+
+                    cur.execute('select * from data')
+                    out = cur.fetchall()
+                    assert len(out) == 5, len(out)
+                    assert len(out[0]) == 3, len(out[0])
+                    assert isinstance(out[0], tuple), type(out[0])
+                    assert type(out[0]).__name__ == 'Row', type(out[0]).__name__
+                    assert hasattr(out[0], 'id')
+                    assert hasattr(out[0], 'name')
+                    assert hasattr(out[0], 'value')
+                    assert sorted(out) == sorted([
+                        ('a', 'antelopes', 2),
+                        ('b', 'bears', 2),
+                        ('c', 'cats', 5),
+                        ('d', 'dogs', 4),
+                        ('e', 'elephants', 0),
+                    ]), out
+
+                    out = cur.fetchall()
+                    assert len(out) == 0, len(out)
+
+    def test_dict(self):
+        with s2.options(('results.type', 'dicts')):
+            with s2.connect(database=type(self).dbname) as conn:
+                with conn.cursor() as cur:
+                    cur.execute('select * from data')
+                    out = cur.fetchone()
+                    assert type(out) is dict, type(out)
+                    assert len(out) == 3, len(out)
+                    cur.fetchall()
+
+                    cur.execute('select * from data')
+                    out = cur.fetchall()
+                    assert type(out[0]) is dict, type(out[0])
+                    assert len(out) == 5, len(out)
+                    assert len(out[0]) == 3, len(out[0])
+                    assert sorted(out, key=lambda x: x['id']) == sorted(
+                        [
+                            dict(id='a', name='antelopes', value=2),
+                            dict(id='b', name='bears', value=2),
+                            dict(id='c', name='cats', value=5),
+                            dict(id='d', name='dogs', value=4),
+                            dict(id='e', name='elephants', value=0),
+                        ], key=lambda x: x['id'],
+                    )
+
+                    out = cur.fetchall()
+                    assert len(out) == 0, len(out)
+
+    def _test_dataframe(self):
+        with s2.options(('results.type', 'dataframe')):
+            with s2.connect(database=type(self).dbname) as conn:
+                with conn.cursor() as cur:
+                    cur.execute('select * from data')
+                    out = cur.fetchone()
+                    assert type(out) is pd.DataFrame, type(out)
+                    assert len(out) == 1, len(out)
+                    cur.fetchall()
+
+                    cur.execute('select * from data')
+                    out = cur.fetchall()
+                    assert type(out) is pd.DataFrame, type(out)
+                    assert len(out) == 5, len(out)
+                    out = out.sort_values('id').reset_index(drop=True)
+                    exp = pd.DataFrame(
+                        data=[
+                            ('a', 'antelopes', 2),
+                            ('b', 'bears', 2),
+                            ('c', 'cats', 5),
+                            ('d', 'dogs', 4),
+                            ('e', 'elephants', 0),
+                        ], columns=['id', 'name', 'value'],
+                    ).sort_values('id').reset_index(drop=True)
+                    assert list(out.columns) == list(exp.columns), list(out.columns)
+                    assert [list(x) for x in list(out.values)] == \
+                           [list(x) for x in list(exp.values)], \
+                           [list(x) for x in list(out.values)]
+
+                    out = cur.fetchall()
+                    assert len(out) == 0, len(out)
+
+
+if __name__ == '__main__':
+    import nose2
+    nose2.main()

singlestoredb/tests/test_types.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+# type: ignore
+"""Test SingleStoreDB data types."""
+import datetime
+import unittest
+
+import singlestoredb.types as st
+
+
+class TestTypes(unittest.TestCase):
+
+    def test_date_from_ticks(self):
+        dt = st.DateFromTicks(9999)
+        ts = datetime.date.fromtimestamp(9999)
+        assert dt == ts
+
+    def test_time_from_ticks(self):
+        tm = st.TimeFromTicks(9999)
+        ts = datetime.datetime.fromtimestamp(9999)
+        ts = datetime.time(hour=ts.hour, minute=ts.minute, second=ts.second)
+        assert tm == ts
+
+    def test_timestamp_from_ticks(self):
+        tm = st.TimestampFromTicks(9999)
+        ts = datetime.datetime.fromtimestamp(9999)
+        assert tm == ts
+
+    def test_dbapitype_eq(self):
+        ct = st.ColumnType
+
+        assert st.STRING == ct.CHAR
+        assert st.STRING == 'CHAR'
+        assert st.STRING == 254
+        assert st.STRING == ct.VARCHAR
+        assert st.STRING == 'VARCHAR'
+        assert st.STRING == 15
+        assert st.STRING == ct.VARSTRING
+        assert st.STRING == 'VARSTRING'
+        assert st.STRING == 253
+        assert st.STRING == ct.STRING
+        assert st.STRING == 'STRING'
+        assert st.STRING != 'BINARY'
+        assert st.STRING != 'VARBINARY'
+
+        # Because MySQL uses the same type code for strings and binary
+        # we can't tell the difference between these.
+        # assert st.STRING != ct.BINARY
+
+        assert st.BINARY == ct.BINARY
+        assert st.BINARY == ct.VARBINARY
+
+        assert st.NUMBER == ct.DECIMAL
+        assert st.NUMBER == ct.TINY
+        assert st.NUMBER == ct.LONG
+        assert st.NUMBER == ct.FLOAT
+        assert st.NUMBER == ct.DOUBLE
+        assert st.NUMBER != ct.STRING
+        assert st.NUMBER != ct.BINARY
+
+        assert st.DATETIME == ct.DATETIME
+        assert st.DATETIME != ct.YEAR
+        assert st.DATETIME != ct.DATE
+        assert st.DATETIME != ct.TIME
+
+        assert st.ROWID != ct.LONG
+        assert st.ROWID != ct.STRING
+        assert st.ROWID != ct.BINARY
+
+    def test_str(self):
+        out = str(st.NUMBER)
+        assert 'BIGINT' in out
+        assert 'BIT' in out
+        assert 'BOOL' in out
+        assert 'DECIMAL' in out
+        assert 'LONG' in out
+        assert '246' in out
+
+    def test_repr(self):
+        assert str(st.NUMBER) == repr(st.NUMBER)
+
+    def test_name(self):
+        ct = st.ColumnType
+        assert ct.DEC.name == 'DECIMAL', ct.DEC.name
+        assert ct.BOOL.name == 'TINY', ct.BOOL.name
+        assert ct.BIT.name == 'BIT', ct.BIT.name
+        assert ct.LONGBLOB.name == 'LONGBLOB', ct.LONGBLOB.name
+        assert ct.LONGTEXT.name == 'LONGTEXT', ct.LONGTEXT.name
+
+    def test_code(self):
+        ct = st.ColumnType
+        assert ct.DEC.code == 0, ct.DEC.code
+        assert ct.BOOL.code == 1, ct.BOOL.code
+        assert ct.BIT.code == 16, ct.BIT.code
+        assert ct.LONGBLOB.code == 251, ct.LONGBLOB.code
+        assert ct.LONGTEXT.code == 251, ct.LONGTEXT.code
+
+    def test_get_code(self):
+        ct = st.ColumnType
+        assert ct.get_code('DECIMAL') == 0, ct.get_code('DECIMAL')
+        assert ct.get_code('TINY') == 1, ct.get_code('TINY')
+        assert ct.get_code('BIT') == 16, ct.get_code('BIT')
+        assert ct.get_code('LONGBLOB') == 251, ct.get_code('LONGBLOB')
+        assert ct.get_code('LONGTEXT') == 251, ct.get_code('LONGTEXT')
+
+        assert ct.get_code(0) == 0, ct.get_code(0)
+        assert ct.get_code(1) == 1, ct.get_code(1)
+        assert ct.get_code(16) == 16, ct.get_code(16)
+
+        assert ct.get_code(int) == 8, ct.get_code(int)
+        assert ct.get_code(float) == 5, ct.get_code(float)
+        assert ct.get_code(str) == 15, ct.get_code(str)
+
+    def test_get_name(self):
+        ct = st.ColumnType
+        assert ct.get_name(0) == 'DECIMAL', ct.get_name(0)
+        assert ct.get_name(1) == 'TINY', ct.get_name(1)
+        assert ct.get_name(16) == 'BIT', ct.get_name(16)
+        assert ct.get_name(251) == 'LONGBLOB', ct.get_name(251)
+        assert ct.get_name(251) == 'LONGBLOB', ct.get_name(251)
+
+        assert ct.get_name('dec') == 'DECIMAL', ct.get_name('dec')
+        assert ct.get_name('bool') == 'TINY', ct.get_name('bool')
+        assert ct.get_name('bigint') == 'BIGINT', ct.get_name('bigint')
+
+        assert ct.get_name(int) == 'BIGINT', ct.get_name(int)
+        assert ct.get_name(float) == 'DOUBLE', ct.get_name(float)
+        assert ct.get_name(str) == 'VARBINARY', ct.get_name(str)
+
+
+if __name__ == '__main__':
+    import nose2
+    nose2.main()