singlestoredb 0.7.1__tar.gz → 0.7.3__tar.gz

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: singlestoredb
-Version: 0.7.1
+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

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = singlestoredb
-version = 0.7.1
+version = 0.7.3
 description = Interface to the SingleStore database and cluster management APIs
 long_description = file: README.md
 long_description_content_type = text/markdown

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/singlestoredb/__init__.py

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

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/singlestoredb/config.py

@@ -230,3 +230,10 @@ register_option(
     'Print queries and parameters to stderr.',
     environ='SINGLESTOREDB_DEBUG_QUERIES',
 )
+
+
+register_option(
+    'debug.connection', 'bool', check_bool, False,
+    'Print connection tracing information.',
+    environ='SINGLESTOREDB_DEBUG_CONNECTION',
+)

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/singlestoredb/mysql/_auth.py

@@ -16,8 +16,10 @@ except ImportError:
 from functools import partial
 import hashlib
 
+from ..config import get_option
 
-DEBUG = False
+
+DEBUG = get_option('debug.connection')
 SCRAMBLE_LENGTH = 20
 sha1_new = partial(hashlib.new, 'sha1')
 

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/singlestoredb/mysql/accel.c

@@ -1031,10 +1031,10 @@ static unsigned long long read_length_encoded_integer(
             if (is_null) *is_null = 1;
             return 0;
         }
-        uint16_t low = **(uint8_t**)data;
-        *data += 1; *data_l -= 1;
-        uint16_t high = **(uint16_t**)data;
+        uint16_t low = **(uint16_t**)data;
         *data += 2; *data_l -= 2;
+        uint8_t high = **(uint8_t**)data;
+        *data += 1; *data_l -= 1;
         return low + (high << 16);
     }
 

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/singlestoredb/mysql/connection.py

@@ -46,6 +46,7 @@ from .protocol import (
     LoadLocalPacketWrapper,
 )
 from . import err
+from ..config import get_option
 from ..connection import Connection as BaseConnection
 
 try:
@@ -65,7 +66,7 @@ except (ImportError, KeyError):
     # KeyError occurs when there's no entry in OS database for a current user.
     DEFAULT_USER = None
 
-DEBUG = False
+DEBUG = get_option('debug.connection')
 
 TEXT_TYPES = {
     FIELD_TYPE.BIT,

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/singlestoredb/mysql/protocol.py

@@ -5,13 +5,14 @@ import struct
 import sys
 
 from . import err
+from ..config import get_option
 from ..utils.results import Description
 from .charset import MBLENGTH
 from .constants import FIELD_TYPE
 from .constants import SERVER_STATUS
 
 
-DEBUG = False
+DEBUG = get_option('debug.connection')
 
 NULL_COLUMN = 251
 UNSIGNED_CHAR_COLUMN = 251

singlestoredb-0.7.3/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-0.7.1 → singlestoredb-0.7.3}/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.1 → singlestoredb-0.7.3}/singlestoredb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: singlestoredb
-Version: 0.7.1
+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

{singlestoredb-0.7.1 → singlestoredb-0.7.3}/singlestoredb.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ singlestoredb/config.py
 singlestoredb/connection.py
 singlestoredb/converters.py
 singlestoredb/exceptions.py
+singlestoredb/pytest.py
 singlestoredb/types.py
 singlestoredb.egg-info/PKG-INFO
 singlestoredb.egg-info/SOURCES.txt