singlestoredb 0.7.2__cp36-abi3-macosx_10_9_universal2.whl → 0.7.3__cp36-abi3-macosx_10_9_universal2.whl

singlestoredb/__init__.py

@@ -13,7 +13,7 @@ Examples
 
 """
 
-__version__ = '0.7.2'
+__version__ = '0.7.3'
 
 from .config import options, get_option, set_option, describe_option
 from .connection import connect, apilevel, threadsafety, paramstyle

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}')

singlestoredb/tests/test_basics.py

@@ -4,6 +4,7 @@
 import datetime
 import decimal
 import os
+import string
 import unittest
 
 try:
@@ -1105,6 +1106,59 @@ class TestBasics(unittest.TestCase):
         self.cur.execute(f"SELECT 1999 :> YEAR, '{string}'")
         self.assertEqual((1999, string), self.cur.fetchone())
 
+    def test_character_lengths(self):
+        if self.conn.driver in ['http', 'https']:
+            self.skipTest('Response size too big for http')
+
+        test_id = id(self)
+        self.cur.execute(rf'''
+            CREATE TABLE `test_character_lengths_{test_id}` (
+                `id` text CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
+                `char_col` longtext CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
+                `int_col` INT,
+                PRIMARY KEY (`id`),
+                SORT KEY `id` (`id`)
+            ) AUTOSTATS_CARDINALITY_MODE=INCREMENTAL
+              AUTOSTATS_HISTOGRAM_MODE=CREATE
+              AUTOSTATS_SAMPLING=ON
+              SQL_MODE='STRICT_ALL_TABLES'
+        ''')
+        CHAR_STR = string.ascii_letters * 1
+        SHORT_STR = string.ascii_letters * 10
+        INT24_STR = string.ascii_letters * 1500
+        INT64_STR = string.ascii_letters * 1500000
+        data = [
+            ['CHAR', CHAR_STR, 123456],
+            ['SHORT', SHORT_STR, 123456],
+            ['INT24', INT24_STR, 123456],
+            ['INT64', INT64_STR, 123456],
+        ]
+        self.cur.executemany(
+            f'INSERT INTO test_character_lengths_{test_id}(id, char_col, int_col) '
+            'VALUES (%s, %s, %s)', data,
+        )
+        self.cur.execute(
+            f'SELECT id, char_col, int_col FROM test_character_lengths_{test_id} '
+            'WHERE id = "CHAR"',
+        )
+        assert data[0] == list(list(self.cur)[0])
+        self.cur.execute(
+            f'SELECT id, char_col, int_col FROM test_character_lengths_{test_id} '
+            'WHERE id = "SHORT"',
+        )
+        assert data[1] == list(list(self.cur)[0])
+        self.cur.execute(
+            f'SELECT id, char_col, int_col FROM test_character_lengths_{test_id} '
+            'WHERE id = "INT24"',
+        )
+        assert data[2] == list(list(self.cur)[0])
+        self.cur.execute(
+            f'SELECT id, char_col, int_col FROM test_character_lengths_{test_id} '
+            'WHERE id = "INT64"',
+        )
+        assert data[3] == list(list(self.cur)[0])
+        self.cur.execute(rf'DROP TABLE `test_character_lengths_{test_id}`')
+
 
 if __name__ == '__main__':
     import nose2

{singlestoredb-0.7.2.dist-info → singlestoredb-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: singlestoredb
-Version: 0.7.2
+Version: 0.7.3
 Summary: Interface to the SingleStore database and cluster management APIs
 Home-page: https://github.com/singlestore-labs/singlestoredb-python
 Author: SingleStore
@@ -29,7 +29,7 @@ Requires-Dist: ibis-singlestoredb ; extra == 'dataframe'
 Provides-Extra: dbt
 Requires-Dist: dbt-singlestore ; extra == 'dbt'
 Provides-Extra: ed22519
-Requires-Dist: PyNaCl (>=1.4.0) ; extra == 'ed22519'
+Requires-Dist: PyNaCl >=1.4.0 ; extra == 'ed22519'
 Provides-Extra: gssapi
 Requires-Dist: gssapi ; extra == 'gssapi'
 Provides-Extra: ibis

{singlestoredb-0.7.2.dist-info → singlestoredb-0.7.3.dist-info}/RECORD

@@ -1,20 +1,21 @@
-_singlestoredb_accel.abi3.so,sha256=W4mULplyf83bn4BMzZoen93krX0gfJ1tGlH_I-Xy8XY,154845
-singlestoredb-0.7.2.dist-info/RECORD,,
-singlestoredb-0.7.2.dist-info/LICENSE,sha256=Mlq78idURT-9G026aMYswwwnnrLcgzTLuXeAs5hjDLM,11341
-singlestoredb-0.7.2.dist-info/WHEEL,sha256=L_8uSJgNH7VmiqwHcew_IFGyTcruK-C2YxnyqVh4uE0,113
-singlestoredb-0.7.2.dist-info/top_level.txt,sha256=SDtemIXf-Kp-_F2f_S6x0db33cHGOILdAEsIQZe2LZc,35
-singlestoredb-0.7.2.dist-info/METADATA,sha256=iKxctiVg99Pwq53QbDJbqspSyaTvBLjNiuyYhyWgBlE,7857
+_singlestoredb_accel.abi3.so,sha256=CITR7xiU8llX-0oeejt3Bb21dcOcTIzi2MNRxTe2rMI,154873
+singlestoredb-0.7.3.dist-info/RECORD,,
+singlestoredb-0.7.3.dist-info/LICENSE,sha256=Mlq78idURT-9G026aMYswwwnnrLcgzTLuXeAs5hjDLM,11341
+singlestoredb-0.7.3.dist-info/WHEEL,sha256=VAdTNBN2V38nmUxcCdubY6bt9wfLIj6Xfitk92_u7J4,113
+singlestoredb-0.7.3.dist-info/top_level.txt,sha256=SDtemIXf-Kp-_F2f_S6x0db33cHGOILdAEsIQZe2LZc,35
+singlestoredb-0.7.3.dist-info/METADATA,sha256=R8gcwGj8LM0EAxwOyA-Q42OFBtGciwQ91yK2P_GrIYU,7855
 singlestoredb/auth.py,sha256=u8D9tpKzrqa4ssaHjyZnGDX1q8XBpGtuoOkTkSv7B28,7599
 singlestoredb/config.py,sha256=c8UG3qL2atjECS-9FOgUpixqQmiAc26GYh9W-9N6Wgk,6477
-singlestoredb/__init__.py,sha256=0BGzlQjoEKbX8hiKKsMQVJ5sIjdgHnX8LbDw6_2m1-M,842
+singlestoredb/__init__.py,sha256=4vHLXqAI-ijhpK5HRZJb439GiNeP8cbCk1IgIb3R4L4,842
 singlestoredb/types.py,sha256=FIqO1A7e0Gkk7ITmIysBy-P5S--ItbMSlYvblzqGS30,9969
 singlestoredb/connection.py,sha256=8vdmPj6CsJpHe6bJfKT_b8AinXCD3XHSOT8_ljMJ2ZI,43470
+singlestoredb/pytest.py,sha256=OyF3BO9mgxenifYhOihnzGk8WzCJ_zN5_mxe8XyFPOc,9074
 singlestoredb/exceptions.py,sha256=HiHRMO36MT06RM-LfURlA6AadCiQtnOodxJtZorKJzU,2459
 singlestoredb/converters.py,sha256=aH_QhLr94i9_AjvcplTar0HfX2yi53KGxHHzJc7lSU0,12515
 singlestoredb/tests/test.sql,sha256=9fIAnyjLYNJd6NrSP2k109EYULno9_DDiMG5OE6JARY,8968
 singlestoredb/tests/test_xdict.py,sha256=fqHspoi39nbX3fIDVkkRXcd5H50xdOsSvK0bxAMQnaE,10408
 singlestoredb/tests/test_results.py,sha256=5S4M6gK69HZnYV7O9I2Onx9gfZpUi52RD4Jm7ETahxo,6582
-singlestoredb/tests/test_basics.py,sha256=31puc1yB9lq17t7UsTS0NHi6AirOBNfbKdQZrdiYD4c,40220
+singlestoredb/tests/test_basics.py,sha256=-ejNGyv1XB52oqz65Ls6ABPknQc1pM_xsYJV46XtC5I,42401
 singlestoredb/tests/test_connection.py,sha256=Qay7_oNl0EQahipZZZCAiLOcsQwL4OEtGmc_rnQ-eLM,50732
 singlestoredb/tests/test_exceptions.py,sha256=tfr_8X2w1UmG4nkSBzWGB0C7ehrf1GAVgj6_ODaG-TM,1131
 singlestoredb/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

{singlestoredb-0.7.2.dist-info → singlestoredb-0.7.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: false
 Tag: cp36-abi3-macosx_10_9_universal2