singlestoredb 0.4.0__py3-none-any.whl → 1.0.4__py3-none-any.whl

singlestoredb/{clients/pymysqlsv → mysql}/tests/thirdparty/test_MySQLdb/dbapi20.py

@@ -66,7 +66,9 @@ import unittest
 
 
 class DatabaseAPI20Test(unittest.TestCase):
-    """Test a database self.driver for DB API 2.0 compatibility.
+    """
+    Test a database self.driver for DB API 2.0 compatibility.
+
     This implementation tests Gadfly, but the TestCase
     is structured so that other self.drivers can subclass this
     test case to ensure compiliance with the DB-API. It is
@@ -85,6 +87,7 @@ class DatabaseAPI20Test(unittest.TestCase):
 
     Don't 'import DatabaseAPI20Test from dbapi20', or you will
     confuse the unit tester - just 'import dbapi20'.
+
     """
 
     # The self.driver module. This should be the module where the 'connect'
@@ -110,15 +113,23 @@ class DatabaseAPI20Test(unittest.TestCase):
         cursor.execute(self.ddl2)
 
     def setUp(self):
-        """self.drivers should override this method to perform required setup
+        """
+        Setup the tests.
+
+        self.drivers should override this method to perform required setup
         if any is necessary, such as creating the database.
+
         """
         pass
 
     def tearDown(self):
-        """self.drivers should override this method to perform required cleanup
+        """
+        Tear down the tests.
+
+        self.drivers should override this method to perform required cleanup
         if any is necessary, such as deleting the test database.
         The default drops the tables that may be created.
+
         """
         con = self._connect()
         try:
@@ -226,7 +237,7 @@ class DatabaseAPI20Test(unittest.TestCase):
     def test_cursor(self):
         con = self._connect()
         try:
-            cur = con.cursor()
+            cur = con.cursor()  # noqa: F841
         finally:
             con.close()
 
@@ -266,7 +277,7 @@ class DatabaseAPI20Test(unittest.TestCase):
             )
             self.assertEqual(
                 len(cur.description[0]),
-                7,
+                9,
                 'cursor.description[x] tuples must have 7 elements',
             )
             self.assertEqual(
@@ -280,6 +291,7 @@ class DatabaseAPI20Test(unittest.TestCase):
                 'cursor.description[x][1] must return column type. Got %r'
                 % cur.description[0][1],
             )
+            cur.fetchall()
 
             # Make sure self.description gets reset
             self.executeDDL2(cur)
@@ -684,7 +696,7 @@ class DatabaseAPI20Test(unittest.TestCase):
             for sql in self._populate():
                 cur.execute(sql)
 
-            cur.execute('select name from %sbooze' % self.table_prefix)
+            cur.execute('select name from %sbooze order by name' % self.table_prefix)
             rows1 = cur.fetchone()
             rows23 = cur.fetchmany(2)
             rows4 = cur.fetchone()
@@ -750,17 +762,14 @@ class DatabaseAPI20Test(unittest.TestCase):
                 assert cur.nextset()
                 names = cur.fetchall()
                 assert len(names) == len(self.samples)
-                s = cur.nextset()
-                assert s == None, 'No more return sets, should return None'
+                s = cur.nextset()  # noqa: F841
+                assert s is None, 'No more return sets, should return None'
             finally:
                 self.help_nextset_tearDown(cur)
 
         finally:
             con.close()
 
-    def test_nextset(self):
-        raise NotImplementedError('Drivers need to override this test')
-
     def test_arraysize(self):
         # Not much here - rest of the tests for this are in test_fetchmany
         con = self._connect()
@@ -811,28 +820,28 @@ class DatabaseAPI20Test(unittest.TestCase):
             con.close()
 
     def test_Date(self):
-        d1 = self.driver.Date(2002, 12, 25)
-        d2 = self.driver.DateFromTicks(time.mktime((2002, 12, 25, 0, 0, 0, 0, 0, 0)))
+        self.driver.Date(2002, 12, 25)
+        self.driver.DateFromTicks(time.mktime((2002, 12, 25, 0, 0, 0, 0, 0, 0)))
         # Can we assume this? API doesn't specify, but it seems implied
-        # self.assertEqual(str(d1),str(d2))
+        # self.assertEqual(str(d1), str(d2))
 
     def test_Time(self):
-        t1 = self.driver.Time(13, 45, 30)
-        t2 = self.driver.TimeFromTicks(time.mktime((2001, 1, 1, 13, 45, 30, 0, 0, 0)))
+        self.driver.Time(13, 45, 30)
+        self.driver.TimeFromTicks(time.mktime((2001, 1, 1, 13, 45, 30, 0, 0, 0)))
         # Can we assume this? API doesn't specify, but it seems implied
-        # self.assertEqual(str(t1),str(t2))
+        # self.assertEqual(str(t1), str(t2))
 
     def test_Timestamp(self):
-        t1 = self.driver.Timestamp(2002, 12, 25, 13, 45, 30)
-        t2 = self.driver.TimestampFromTicks(
+        self.driver.Timestamp(2002, 12, 25, 13, 45, 30)
+        self.driver.TimestampFromTicks(
             time.mktime((2002, 12, 25, 13, 45, 30, 0, 0, 0)),
         )
         # Can we assume this? API doesn't specify, but it seems implied
-        # self.assertEqual(str(t1),str(t2))
+        # self.assertEqual(str(t1), str(t2))
 
     def test_Binary(self):
-        b = self.driver.Binary(b'Something')
-        b = self.driver.Binary(b'')
+        self.driver.Binary(b'Something')
+        self.driver.Binary(b'')
 
     def test_STRING(self):
         self.assertTrue(hasattr(self.driver, 'STRING'), 'module.STRING must be defined')

singlestoredb/{clients/pymysqlsv → mysql}/tests/thirdparty/test_MySQLdb/test_MySQLdb_capabilities.py

@@ -1,10 +1,9 @@
 # type: ignore
-import unittest
 import warnings
 
-import singlestoredb.clients.pymysqlsv as sv
+import singlestoredb.mysql as sv
 from . import capabilities
-from singlestoredb.clients.pymysqlsv.tests import base
+from singlestoredb.mysql.tests import base
 
 warnings.filterwarnings('error')
 
@@ -91,7 +90,7 @@ class test_MySQLdb(capabilities.DatabaseTest):
         self.check_data_integrity(('col1 char(1)', 'col2 char(1)'), generator)
 
     def test_bug_2671682(self):
-        from singlestoredb.clients.pymysqlsv.constants import ER
+        from singlestoredb.mysql.constants import ER
 
         try:
             self.cursor.execute('describe some_non_existent_table')

singlestoredb/{clients/pymysqlsv → mysql}/tests/thirdparty/test_MySQLdb/test_MySQLdb_dbapi20.py

@@ -1,12 +1,11 @@
 # type: ignore
-import unittest
-
-import singlestoredb.clients.pymysqlsv as sv
+import singlestoredb.mysql as sv
 from . import dbapi20
-from singlestoredb.clients.pymysqlsv.tests import base
+from singlestoredb.mysql.tests import base
 
 
 class test_MySQLdb(dbapi20.DatabaseAPI20Test):
+
     driver = sv
     connect_args = ()
     connect_kw_args = base.PyMySQLTestCase.databases[0].copy()
@@ -24,10 +23,10 @@ class test_MySQLdb(dbapi20.DatabaseAPI20Test):
     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."""
+    # 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()
@@ -120,8 +119,9 @@ class test_MySQLdb(dbapi20.DatabaseAPI20Test):
             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.assertEqual(cur.fetchone(), None,
+            #                  'cursor.fetchone should return None if '
+            #                  'no more rows available'
             # )
             self.assertTrue(cur.rowcount in (-1, 1))
         finally:
@@ -134,15 +134,15 @@ class test_MySQLdb(dbapi20.DatabaseAPI20Test):
             cur = con.cursor()
             self.executeDDL1(cur)
             # self.assertEqual(cur.rowcount,-1,
-            ##                 'cursor.rowcount should be -1 after executing no-result '
+            #                  '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'
+            #                  '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(
@@ -150,10 +150,11 @@ class test_MySQLdb(dbapi20.DatabaseAPI20Test):
                 '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'
+        # self.assertEqual(cur.rowcount, -1,
+        #                  'cursor.rowcount not being reset to -1 after executing '
+        #                  'no-result statements'
         # )
         finally:
             con.close()
@@ -178,11 +179,11 @@ class test_MySQLdb(dbapi20.DatabaseAPI20Test):
         cur.execute(sql)
 
     def help_nextset_tearDown(self, cur):
-        'If cleaning up is needed after nextSetTest'
+        # If cleaning up is needed after nextSetTest
         cur.execute('drop procedure deleteme')
 
     def test_nextset(self):
-        from warnings import warn
+        # from warnings import warn
 
         con = self._connect()
         try:
@@ -201,6 +202,8 @@ class test_MySQLdb(dbapi20.DatabaseAPI20Test):
                 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)
@@ -210,8 +213,9 @@ class test_MySQLdb(dbapi20.DatabaseAPI20Test):
                     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)
+                    # 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)

singlestoredb/{clients/pymysqlsv → mysql}/tests/thirdparty/test_MySQLdb/test_MySQLdb_nonstandard.py

@@ -1,15 +1,15 @@
 # type: ignore
-import sys
 import unittest
 
-import singlestoredb.clients.pymysqlsv as sv
-from singlestoredb.clients.pymysqlsv.constants import FIELD_TYPE
-from singlestoredb.clients.pymysqlsv.tests import base
+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)
 

singlestoredb/{clients/pymysqlsv → mysql}/times.py

@@ -1,4 +1,3 @@
-# type: ignore
 from datetime import date
 from datetime import datetime
 from datetime import time
@@ -12,13 +11,13 @@ TimeDelta = timedelta
 Timestamp = datetime
 
 
-def DateFromTicks(ticks):
+def DateFromTicks(ticks: int) -> date:
     return date(*localtime(ticks)[:3])
 
 
-def TimeFromTicks(ticks):
+def TimeFromTicks(ticks: int) -> time:
     return time(*localtime(ticks)[3:6])
 
 
-def TimestampFromTicks(ticks):
+def TimestampFromTicks(ticks: int) -> datetime:
     return datetime(*localtime(ticks)[:6])

singlestoredb/pytest.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python
+"""Pytest plugin"""
+import logging
+import os
+import subprocess
+import time
+from enum import Enum
+from typing import Iterator
+from typing import Optional
+
+import pytest
+
+from . import connect
+from .connection import Connection
+from .connection import Cursor
+
+
+logger = logging.getLogger(__name__)
+
+
+# How many times to attempt to connect to the container
+STARTUP_CONNECT_ATTEMPTS = 10
+# How long to wait between connection attempts
+STARTUP_CONNECT_TIMEOUT_SECONDS = 2
+# How many times to check if all connections are closed
+TEARDOWN_WAIT_ATTEMPTS = 20
+# How long to wait between checking connections
+TEARDOWN_WAIT_SECONDS = 2
+
+
+class ExecutionMode(Enum):
+    SEQUENTIAL = 1
+    LEADER = 2
+    FOLLOWER = 3
+
+
+@pytest.fixture(scope='session')
+def execution_mode() -> ExecutionMode:
+    """Determine the pytest mode for this process"""
+
+    worker = os.environ.get('PYTEST_XDIST_WORKER')
+    worker_count = os.environ.get('PYTEST_XDIST_WORKER_COUNT')
+
+    # If we're not in pytest-xdist, the mode is Sequential
+    if worker is None or worker_count is None:
+        logger.debug('XDIST environment vars not found')
+        return ExecutionMode.SEQUENTIAL
+
+    logger.debug(f'PYTEST_XDIST_WORKER == {worker}')
+    logger.debug(f'PYTEST_XDIST_WORKER_COUNT == {worker_count}')
+
+    # If we're the only worker, than the mode is Sequential
+    if worker_count == '1':
+        return ExecutionMode.SEQUENTIAL
+    else:
+        # The first worker (named "gw0") is the leader
+        # if there are multiple workers
+        if worker == 'gw0':
+            return ExecutionMode.LEADER
+        else:
+            return ExecutionMode.FOLLOWER
+
+
+@pytest.fixture(scope='session')
+def node_name() -> Iterator[str]:
+    """Determine the name of this worker node"""
+
+    worker = os.environ.get('PYTEST_XDIST_WORKER')
+
+    if worker is None:
+        logger.debug('XDIST environment vars not found')
+        yield 'master'
+    else:
+        logger.debug(f'PYTEST_XDIST_WORKER == {worker}')
+        yield worker
+
+
+class _TestContainerManager():
+    """Manages the setup and teardown of a SingleStoreDB Dev Container"""
+
+    def __init__(self) -> None:
+        self.container_name = 'singlestoredb-test-container'
+        self.dev_image_name = 'ghcr.io/singlestore-labs/singlestoredb-dev'
+
+        assert 'SINGLESTORE_LICENSE' in os.environ, 'SINGLESTORE_LICENSE not set'
+
+        self.root_password = 'Q8r4D7yXR8oqn'
+        self.environment_vars = {
+            'SINGLESTORE_LICENSE': None,
+            'ROOT_PASSWORD': f"\"{self.root_password}\"",
+            'SINGLESTORE_SET_GLOBAL_DEFAULT_PARTITIONS_PER_LEAF': '1',
+        }
+
+        self.ports = ['3306', '8080', '9000']
+
+        self.url = f'root:{self.root_password}@127.0.0.1:3306'
+
+    def start(self) -> None:
+        command = ' '.join(self._start_command())
+
+        logger.info(f'Starting container {self.container_name}')
+        try:
+            license = os.environ['SINGLESTORE_LICENSE']
+            env = {
+                'SINGLESTORE_LICENSE': license,
+            }
+            subprocess.check_call(command, shell=True, env=env)
+        except Exception as e:
+            logger.exception(e)
+            raise RuntimeError(
+                'Failed to start container. '
+                'Is one already running?',
+            ) from e
+        logger.debug('Container started')
+
+    def _start_command(self) -> Iterator[str]:
+        yield 'docker run -d --name'
+        yield self.container_name
+        for key, value in self.environment_vars.items():
+            yield '-e'
+            if value is None:
+                yield key
+            else:
+                yield f'{key}={value}'
+
+        for port in self.ports:
+            yield '-p'
+            yield f'{port}:{port}'
+
+        yield self.dev_image_name
+
+    def print_logs(self) -> None:
+        logs_command = ['docker', 'logs', self.container_name]
+        logger.info('Getting logs')
+        logger.info(subprocess.check_output(logs_command))
+
+    def connect(self) -> Connection:
+        # Run all but one attempts trying again if they fail
+        for i in range(STARTUP_CONNECT_ATTEMPTS - 1):
+            try:
+                return connect(self.url)
+            except Exception:
+                logger.debug(f'Database not available yet (attempt #{i}).')
+                time.sleep(STARTUP_CONNECT_TIMEOUT_SECONDS)
+        else:
+            # Try one last time and report error if it fails
+            try:
+                return connect(self.url)
+            except Exception as e:
+                logger.error('Timed out while waiting to connect to database.')
+                logger.exception(e)
+                self.print_logs()
+                raise RuntimeError('Failed to connect to database') from e
+
+    def wait_till_connections_closed(self) -> None:
+        heart_beat = connect(self.url)
+        for i in range(TEARDOWN_WAIT_ATTEMPTS):
+            connections = self.get_open_connections(heart_beat)
+            if connections is None:
+                raise RuntimeError('Could not determine the number of open connections.')
+            logger.debug(
+                f'Waiting for other connections (n={connections-1}) '
+                f'to close (attempt #{i})',
+            )
+            time.sleep(TEARDOWN_WAIT_SECONDS)
+        else:
+            logger.warning('Timed out while waiting for other connections to close')
+            self.print_logs()
+
+    def get_open_connections(self, conn: Connection) -> Optional[int]:
+        for row in conn.show.status(extended=True):
+            name = row['Name']
+            value = row['Value']
+            logger.info(f'{name} = {value}')
+            if name == 'Threads_connected':
+                return int(value)
+
+        return None
+
+    def stop(self) -> None:
+        logger.info('Cleaning up SingleStore DB dev container')
+        logger.debug('Stopping container')
+        try:
+            subprocess.check_call(f'docker stop {self.container_name}', shell=True)
+        except Exception as e:
+            logger.exception(e)
+            raise RuntimeError('Failed to stop container.') from e
+
+        logger.debug('Removing container')
+        try:
+            subprocess.check_call(f'docker rm {self.container_name}', shell=True)
+        except Exception as e:
+            logger.exception(e)
+            raise RuntimeError('Failed to stop container.') from e
+
+
+@pytest.fixture(scope='session')
+def singlestoredb_test_container(
+    execution_mode: ExecutionMode,
+) -> Iterator[_TestContainerManager]:
+    """Sets up and tears down the test container"""
+
+    if not isinstance(execution_mode, ExecutionMode):
+        raise TypeError(f"Invalid execution mode '{execution_mode}'")
+
+    container_manager = _TestContainerManager()
+
+    # In sequential operation do all the steps
+    if execution_mode == ExecutionMode.SEQUENTIAL:
+        logger.debug('Not distributed')
+        container_manager.start()
+        yield container_manager
+        container_manager.stop()
+
+    # In distributed execution as leader,
+    # do the steps but wait for other workers before stopping
+    elif execution_mode == ExecutionMode.LEADER:
+        logger.debug('Distributed leader')
+        container_manager.start()
+        yield container_manager
+        container_manager.wait_till_connections_closed()
+        container_manager.stop()
+
+    # In distributed exeuction as a non-leader,
+    # don't worry about the container lifecycle
+    elif execution_mode == ExecutionMode.FOLLOWER:
+        logger.debug('Distributed follower')
+        yield container_manager
+
+
+@pytest.fixture(scope='session')
+def singlestoredb_connection(
+    singlestoredb_test_container: _TestContainerManager,
+) -> Iterator[Connection]:
+    """Creates and closes the connection"""
+
+    connection = singlestoredb_test_container.connect()
+    logger.debug('Connected to database.')
+
+    yield connection
+
+    logger.debug('Closing connection')
+    connection.close()
+
+
+class _NameAllocator():
+    """Generates unique names for each database"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+        self.names = 0
+
+    def get_name(self) -> str:
+        name = f'x_db_{self.id}_{self.names}'
+        self.names += 1
+        return name
+
+
+@pytest.fixture(scope='session')
+def name_allocator(node_name: str) -> Iterator[_NameAllocator]:
+    """Makes a worker-local name allocator using the node name"""
+
+    yield _NameAllocator(node_name)
+
+
+@pytest.fixture
+def singlestoredb_tempdb(
+    singlestoredb_connection: Connection, name_allocator: _NameAllocator,
+) -> Iterator[Cursor]:
+    """Provides a connection to a unique temporary test database"""
+
+    assert singlestoredb_connection.is_connected(), 'Database is no longer connected'
+    db = name_allocator.get_name()
+
+    with singlestoredb_connection.cursor() as cursor:
+        logger.debug(f"Creating temporary DB \"{db}\"")
+        cursor.execute(f'CREATE DATABASE {db}')
+        cursor.execute(f'USE {db}')
+
+        yield cursor
+
+        logger.debug(f"Dropping temporary DB \"{db}\"")
+        cursor.execute(f'DROP DATABASE {db}')