singlestoredb 1.16.1__py3-none-any.whl

singlestoredb/mysql/err.py

@@ -0,0 +1,92 @@
+import struct
+from typing import Any
+
+from ..exceptions import DatabaseError  # noqa: F401
+from ..exceptions import DataError  # noqa: F401
+from ..exceptions import Error  # noqa: F401
+from ..exceptions import IntegrityError  # noqa: F401
+from ..exceptions import InterfaceError  # noqa: F401
+from ..exceptions import InternalError  # noqa: F401
+from ..exceptions import MySQLError  # noqa: F401
+from ..exceptions import NotSupportedError  # noqa: F401
+from ..exceptions import OperationalError  # noqa: F401
+from ..exceptions import ProgrammingError  # noqa: F401
+from ..exceptions import Warning  # noqa: F401
+from .constants import ER
+
+
+error_map = {}
+
+
+def _map_error(exc: Any, *errors: int) -> None:
+    for error in errors:
+        error_map[error] = exc
+
+
+_map_error(
+    ProgrammingError,
+    ER.DB_CREATE_EXISTS,
+    ER.SYNTAX_ERROR,
+    ER.PARSE_ERROR,
+    ER.NO_SUCH_TABLE,
+    ER.WRONG_DB_NAME,
+    ER.WRONG_TABLE_NAME,
+    ER.FIELD_SPECIFIED_TWICE,
+    ER.INVALID_GROUP_FUNC_USE,
+    ER.UNSUPPORTED_EXTENSION,
+    ER.TABLE_MUST_HAVE_COLUMNS,
+    ER.CANT_DO_THIS_DURING_AN_TRANSACTION,
+    ER.WRONG_DB_NAME,
+    ER.WRONG_COLUMN_NAME,
+)
+_map_error(
+    DataError,
+    ER.WARN_DATA_TRUNCATED,
+    ER.WARN_NULL_TO_NOTNULL,
+    ER.WARN_DATA_OUT_OF_RANGE,
+    ER.NO_DEFAULT,
+    ER.PRIMARY_CANT_HAVE_NULL,
+    ER.DATA_TOO_LONG,
+    ER.DATETIME_FUNCTION_OVERFLOW,
+    ER.TRUNCATED_WRONG_VALUE_FOR_FIELD,
+    ER.ILLEGAL_VALUE_FOR_TYPE,
+)
+_map_error(
+    IntegrityError,
+    ER.DUP_ENTRY,
+    ER.NO_REFERENCED_ROW,
+    ER.NO_REFERENCED_ROW_2,
+    ER.ROW_IS_REFERENCED,
+    ER.ROW_IS_REFERENCED_2,
+    ER.CANNOT_ADD_FOREIGN,
+    ER.BAD_NULL_ERROR,
+)
+_map_error(
+    NotSupportedError,
+    ER.WARNING_NOT_COMPLETE_ROLLBACK,
+    ER.NOT_SUPPORTED_YET,
+    ER.FEATURE_DISABLED,
+    ER.UNKNOWN_STORAGE_ENGINE,
+)
+_map_error(
+    OperationalError,
+    ER.DBACCESS_DENIED_ERROR,
+    ER.ACCESS_DENIED_ERROR,
+    ER.CON_COUNT_ERROR,
+    ER.TABLEACCESS_DENIED_ERROR,
+    ER.COLUMNACCESS_DENIED_ERROR,
+    ER.CONSTRAINT_FAILED,
+    ER.LOCK_DEADLOCK,
+)
+
+
+del _map_error, ER
+
+
+def raise_mysql_exception(data: bytes) -> Exception:
+    errno = struct.unpack('<h', data[1:3])[0]
+    errval = data[9:].decode('utf-8', 'replace')
+    errorclass = error_map.get(errno)
+    if errorclass is None:
+        errorclass = InternalError if errno < 1000 else OperationalError
+    raise errorclass(errno, errval)

singlestoredb/mysql/optionfile.py

@@ -0,0 +1,20 @@
+import configparser
+from typing import Any
+
+
+class Parser(configparser.RawConfigParser):
+
+    def __init__(self, **kwargs: Any) -> None:
+        kwargs['allow_no_value'] = True
+        configparser.RawConfigParser.__init__(self, **kwargs)
+
+    def __remove_quotes(self, value: str) -> str:
+        quotes = ["'", '"']
+        for quote in quotes:
+            if len(value) >= 2 and value[0] == value[-1] == quote:
+                return value[1:-1]
+        return value
+
+    def get(self, section: str, option: str) -> str:  # type: ignore
+        value = configparser.RawConfigParser.get(self, section, option)
+        return self.__remove_quotes(value)

singlestoredb/mysql/protocol.py

@@ -0,0 +1,450 @@
+# type: ignore
+# Python implementation of low level MySQL client-server protocol
+# http://dev.mysql.com/doc/internals/en/client-server-protocol.html
+import struct
+import sys
+
+from . import err
+from ..config import get_option
+from ..utils.results import Description
+from .charset import MBLENGTH
+from .constants import EXTENDED_TYPE
+from .constants import FIELD_TYPE
+from .constants import SERVER_STATUS
+from .constants import VECTOR_TYPE
+
+
+DEBUG = get_option('debug.connection')
+
+NULL_COLUMN = 251
+UNSIGNED_CHAR_COLUMN = 251
+UNSIGNED_SHORT_COLUMN = 252
+UNSIGNED_INT24_COLUMN = 253
+UNSIGNED_INT64_COLUMN = 254
+
+
+def dump_packet(data):  # pragma: no cover
+
+    def printable(data):
+        if 32 <= data < 127:
+            return chr(data)
+        return '.'
+
+    try:
+        print('packet length:', len(data))
+        for i in range(1, 7):
+            f = sys._getframe(i)
+            print('call[%d]: %s (line %d)' % (i, f.f_code.co_name, f.f_lineno))
+        print('-' * 66)
+    except ValueError:
+        pass
+    dump_data = [data[i: i + 16] for i in range(0, min(len(data), 256), 16)]
+    for d in dump_data:
+        print(
+            ' '.join('{:02X}'.format(x) for x in d)
+            + '   ' * (16 - len(d))
+            + ' ' * 2
+            + ''.join(printable(x) for x in d),
+        )
+    print('-' * 66)
+    print()
+
+
+class MysqlPacket:
+    """
+    Representation of a MySQL response packet.
+
+    Provides an interface for reading/parsing the packet results.
+
+    """
+
+    __slots__ = ('_position', '_data')
+
+    def __init__(self, data, encoding):
+        self._position = 0
+        self._data = data
+
+    def get_all_data(self):
+        return self._data
+
+    def read(self, size):
+        """Read the first 'size' bytes in packet and advance cursor past them."""
+        result = self._data[self._position: (self._position + size)]
+        if len(result) != size:
+            error = (
+                'Result length not requested length:\n'
+                'Expected=%s.  Actual=%s.  Position: %s.  Data Length: %s'
+                % (size, len(result), self._position, len(self._data))
+            )
+            if DEBUG:
+                print(error)
+                self.dump()
+            raise AssertionError(error)
+        self._position += size
+        return result
+
+    def read_all(self):
+        """
+        Read all remaining data in the packet.
+
+        (Subsequent read() will return errors.)
+
+        """
+        result = self._data[self._position:]
+        self._position = None  # ensure no subsequent read()
+        return result
+
+    def advance(self, length):
+        """Advance the cursor in data buffer ``length`` bytes."""
+        new_position = self._position + length
+        if new_position < 0 or new_position > len(self._data):
+            raise Exception(
+                'Invalid advance amount (%s) for cursor.  '
+                'Position=%s' % (length, new_position),
+            )
+        self._position = new_position
+
+    def rewind(self, position=0):
+        """Set the position of the data buffer cursor to 'position'."""
+        if position < 0 or position > len(self._data):
+            raise Exception('Invalid position to rewind cursor to: %s.' % position)
+        self._position = position
+
+    def get_bytes(self, position, length=1):
+        """
+        Get 'length' bytes starting at 'position'.
+
+        Position is start of payload (first four packet header bytes are not
+        included) starting at index '0'.
+
+        No error checking is done.  If requesting outside end of buffer
+        an empty string (or string shorter than 'length') may be returned!
+
+        """
+        return self._data[position: (position + length)]
+
+    def read_uint8(self):
+        result = self._data[self._position]
+        self._position += 1
+        return result
+
+    def read_uint16(self):
+        result = struct.unpack_from('<H', self._data, self._position)[0]
+        self._position += 2
+        return result
+
+    def read_uint24(self):
+        low, high = struct.unpack_from('<HB', self._data, self._position)
+        self._position += 3
+        return low + (high << 16)
+
+    def read_uint32(self):
+        result = struct.unpack_from('<I', self._data, self._position)[0]
+        self._position += 4
+        return result
+
+    def read_uint64(self):
+        result = struct.unpack_from('<Q', self._data, self._position)[0]
+        self._position += 8
+        return result
+
+    def read_string(self):
+        end_pos = self._data.find(b'\0', self._position)
+        if end_pos < 0:
+            return None
+        result = self._data[self._position: end_pos]
+        self._position = end_pos + 1
+        return result
+
+    def read_length_encoded_integer(self):
+        """
+        Read a 'Length Coded Binary' number from the data buffer.
+
+        Length coded numbers can be anywhere from 1 to 9 bytes depending
+        on the value of the first byte.
+
+        """
+        c = self.read_uint8()
+        if c == NULL_COLUMN:
+            return None
+        if c < UNSIGNED_CHAR_COLUMN:
+            return c
+        elif c == UNSIGNED_SHORT_COLUMN:
+            return self.read_uint16()
+        elif c == UNSIGNED_INT24_COLUMN:
+            return self.read_uint24()
+        elif c == UNSIGNED_INT64_COLUMN:
+            return self.read_uint64()
+
+    def read_length_coded_string(self):
+        """
+        Read a 'Length Coded String' from the data buffer.
+
+        A 'Length Coded String' consists first of a length coded
+        (unsigned, positive) integer represented in 1-9 bytes followed by
+        that many bytes of binary data.  (For example "cat" would be "3cat".)
+
+        """
+        length = self.read_length_encoded_integer()
+        if length is None:
+            return None
+        return self.read(length)
+
+    def read_struct(self, fmt):
+        s = struct.Struct(fmt)
+        result = s.unpack_from(self._data, self._position)
+        self._position += s.size
+        return result
+
+    def is_ok_packet(self):
+        # https://dev.mysql.com/doc/internals/en/packet-OK_Packet.html
+        return self._data[0] == 0 and len(self._data) >= 7
+
+    def is_eof_packet(self):
+        # http://dev.mysql.com/doc/internals/en/generic-response-packets.html#packet-EOF_Packet
+        # Caution: \xFE may be LengthEncodedInteger.
+        # If \xFE is LengthEncodedInteger header, 8bytes followed.
+        return self._data[0] == 0xFE and len(self._data) < 9
+
+    def is_auth_switch_request(self):
+        # http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::AuthSwitchRequest
+        return self._data[0] == 0xFE
+
+    def is_extra_auth_data(self):
+        # https://dev.mysql.com/doc/internals/en/successful-authentication.html
+        return self._data[0] == 1
+
+    def is_resultset_packet(self):
+        field_count = self._data[0]
+        return 1 <= field_count <= 250
+
+    def is_load_local_packet(self):
+        return self._data[0] == 0xFB
+
+    def is_error_packet(self):
+        return self._data[0] == 0xFF
+
+    def check_error(self):
+        if self.is_error_packet():
+            self.raise_for_error()
+
+    def raise_for_error(self):
+        self.rewind()
+        self.advance(1)  # field_count == error (we already know that)
+        errno = self.read_uint16()
+        if DEBUG:
+            print('errno =', errno)
+        err.raise_mysql_exception(self._data)
+
+    def dump(self):
+        dump_packet(self._data)
+
+
+class FieldDescriptorPacket(MysqlPacket):
+    """
+    A MysqlPacket that represents a specific column's metadata in the result.
+
+    Parsing is automatically done and the results are exported via public
+    attributes on the class such as: db, table_name, name, length, type_code.
+
+    """
+
+    def __init__(self, data, encoding):
+        MysqlPacket.__init__(self, data, encoding)
+        self._parse_field_descriptor(encoding)
+
+    def _parse_field_descriptor(self, encoding):
+        """
+        Parse the 'Field Descriptor' (Metadata) packet.
+
+        This is compatible with MySQL 4.1+ (not compatible with MySQL 4.0).
+
+        """
+        self.catalog = self.read_length_coded_string()
+        self.db = self.read_length_coded_string()
+        self.table_name = self.read_length_coded_string().decode(encoding)
+        self.org_table = self.read_length_coded_string().decode(encoding)
+        self.name = self.read_length_coded_string().decode(encoding)
+        self.org_name = self.read_length_coded_string().decode(encoding)
+        n_bytes = 0
+        (
+            n_bytes,
+            self.charsetnr,
+            self.length,
+            self.type_code,
+            self.flags,
+            self.scale,
+        ) = self.read_struct('<BHIBHBxx')
+
+        # 'default' is a length coded binary and is still in the buffer?
+        # not used for normal result sets...
+
+        # Extended types
+        if n_bytes > 12:
+            ext_type_code = self.read_uint8()
+            if ext_type_code == EXTENDED_TYPE.NONE:
+                pass
+            elif ext_type_code == EXTENDED_TYPE.BSON:
+                self.type_code = FIELD_TYPE.BSON
+            elif ext_type_code == EXTENDED_TYPE.VECTOR:
+                (self.length, vec_type) = self.read_struct('<IB')
+                if vec_type == VECTOR_TYPE.FLOAT32:
+                    if self.charsetnr == 63:
+                        self.type_code = FIELD_TYPE.FLOAT32_VECTOR
+                    else:
+                        self.type_code = FIELD_TYPE.FLOAT32_VECTOR_JSON
+                elif vec_type == VECTOR_TYPE.FLOAT64:
+                    if self.charsetnr == 63:
+                        self.type_code = FIELD_TYPE.FLOAT64_VECTOR
+                    else:
+                        self.type_code = FIELD_TYPE.FLOAT64_VECTOR_JSON
+                elif vec_type == VECTOR_TYPE.INT8:
+                    if self.charsetnr == 63:
+                        self.type_code = FIELD_TYPE.INT8_VECTOR
+                    else:
+                        self.type_code = FIELD_TYPE.INT8_VECTOR_JSON
+                elif vec_type == VECTOR_TYPE.INT16:
+                    if self.charsetnr == 63:
+                        self.type_code = FIELD_TYPE.INT16_VECTOR
+                    else:
+                        self.type_code = FIELD_TYPE.INT16_VECTOR_JSON
+                elif vec_type == VECTOR_TYPE.INT32:
+                    if self.charsetnr == 63:
+                        self.type_code = FIELD_TYPE.INT32_VECTOR
+                    else:
+                        self.type_code = FIELD_TYPE.INT32_VECTOR_JSON
+                elif vec_type == VECTOR_TYPE.INT64:
+                    if self.charsetnr == 63:
+                        self.type_code = FIELD_TYPE.INT64_VECTOR
+                    else:
+                        self.type_code = FIELD_TYPE.INT64_VECTOR_JSON
+                else:
+                    raise TypeError(f'unrecognized vector data type: {vec_type}')
+            else:
+                raise TypeError(f'unrecognized extended data type: {ext_type_code}')
+
+    def description(self):
+        """
+        Provides a 9-item tuple.
+
+        Standard descriptions only have 7 fields according to the Python
+        PEP249 DB Spec, but we need to surface information about unsigned
+        types and charsetnr for proper type handling.
+
+        """
+        precision = self.get_column_length()
+        if self.type_code in (FIELD_TYPE.DECIMAL, FIELD_TYPE.NEWDECIMAL):
+            if precision:
+                precision -= 1  # for the sign
+                if self.scale > 0:
+                    precision -= 1  # for the decimal point
+        return Description(
+            self.name,
+            self.type_code,
+            None,  # TODO: display_length; should this be self.length?
+            self.get_column_length(),  # 'internal_size'
+            precision,  # 'precision'
+            self.scale,
+            self.flags % 2 == 0,
+            self.flags,
+            self.charsetnr,
+        )
+
+    def get_column_length(self):
+        if self.type_code == FIELD_TYPE.VAR_STRING:
+            mblen = MBLENGTH.get(self.charsetnr, 1)
+            return self.length // mblen
+        return self.length
+
+    def __str__(self):
+        return '%s %r.%r.%r, type=%s, flags=%x, charsetnr=%s' % (
+            self.__class__,
+            self.db,
+            self.table_name,
+            self.name,
+            self.type_code,
+            self.flags,
+            self.charsetnr,
+        )
+
+
+class OKPacketWrapper:
+    """
+    OK Packet Wrapper.
+
+    It uses an existing packet object, and wraps around it, exposing
+    useful variables while still providing access to the original packet
+    objects variables and methods.
+
+    """
+
+    def __init__(self, from_packet):
+        if not from_packet.is_ok_packet():
+            raise ValueError(
+                'Cannot create '
+                + str(self.__class__.__name__)
+                + ' object from invalid packet type',
+            )
+
+        self.packet = from_packet
+        self.packet.advance(1)
+
+        self.affected_rows = self.packet.read_length_encoded_integer()
+        self.insert_id = self.packet.read_length_encoded_integer()
+        self.server_status, self.warning_count = self.read_struct('<HH')
+        self.message = self.packet.read_all()
+        self.has_next = self.server_status & SERVER_STATUS.SERVER_MORE_RESULTS_EXISTS
+
+    def __getattr__(self, key):
+        return getattr(self.packet, key)
+
+
+class EOFPacketWrapper:
+    """
+    EOF Packet Wrapper.
+
+    It uses an existing packet object, and wraps around it, exposing
+    useful variables while still providing access to the original packet
+    objects variables and methods.
+
+    """
+
+    def __init__(self, from_packet):
+        if not from_packet.is_eof_packet():
+            raise ValueError(
+                f"Cannot create '{self.__class__}' object from invalid packet type",
+            )
+
+        self.packet = from_packet
+        self.warning_count, self.server_status = self.packet.read_struct('<xhh')
+        if DEBUG:
+            print('server_status=', self.server_status)
+        self.has_next = self.server_status & SERVER_STATUS.SERVER_MORE_RESULTS_EXISTS
+
+    def __getattr__(self, key):
+        return getattr(self.packet, key)
+
+
+class LoadLocalPacketWrapper:
+    """
+    Load Local Packet Wrapper.
+
+    It uses an existing packet object, and wraps around it, exposing useful
+    variables while still providing access to the original packet
+    objects variables and methods.
+
+    """
+
+    def __init__(self, from_packet):
+        if not from_packet.is_load_local_packet():
+            raise ValueError(
+                f"Cannot create '{self.__class__}' object from invalid packet type",
+            )
+
+        self.packet = from_packet
+        self.filename = self.packet.get_all_data()[1:]
+        if DEBUG:
+            print('filename=', self.filename)
+
+    def __getattr__(self, key):
+        return getattr(self.packet, key)

singlestoredb/mysql/tests/__init__.py

@@ -0,0 +1,19 @@
+# type: ignore
+# Sorted by alphabetical order
+from singlestoredb.mysql.tests.test_basic import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_connection import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_converters import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_cursor import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_DictCursor import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_err import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_issues import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_load_local import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_nextset import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_optionfile import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.test_SSCursor import *  # noqa: F403, F401
+from singlestoredb.mysql.tests.thirdparty import *  # noqa: F403, F401
+
+if __name__ == '__main__':
+    import unittest
+
+    unittest.main()

singlestoredb/mysql/tests/base.py

@@ -0,0 +1,126 @@
+# type: ignore
+import json
+import os
+import platform
+import re
+import unittest
+import warnings
+
+import singlestoredb.mysql as sv
+from singlestoredb.connection import build_params
+
+DBNAME_BASE = 'singlestoredb__test_%s_%s_%s_%s_' % \
+              (
+                  *platform.python_version_tuple()[:2],
+                  platform.system(), platform.machine(),
+              )
+
+
+class PyMySQLTestCase(unittest.TestCase):
+    # You can specify your test environment creating a file named
+    #  "databases.json" or editing the `databases` variable below.
+    fname = os.path.join(os.path.dirname(__file__), 'databases.json')
+    if os.path.exists(fname):
+        with open(fname) as f:
+            databases = json.load(f)
+    else:
+        params = build_params()
+        databases = [
+            {
+                'host': params['host'],
+                'port': params['port'],
+                'user': params['user'],
+                'passwd': params['password'],
+                'database': DBNAME_BASE + '1',
+                'use_unicode': True,
+                'local_infile': True,
+                'buffered': params['buffered'],
+            },
+            {
+                'host': params['host'], 'user': params['user'],
+                'port': params['port'], 'passwd': params['password'],
+                'database': DBNAME_BASE + '2',
+                'buffered': params['buffered'],
+            },
+        ]
+
+    def mysql_server_is(self, conn, version_tuple):
+        """
+        Return True if the given connection is on the version given or greater.
+
+        This only checks the server version string provided when the
+        connection is established, therefore any check for a version tuple
+        greater than (5, 5, 5) will always fail on MariaDB, as it always
+        starts with 5.5.5, e.g. 5.5.5-10.7.1-MariaDB-1:10.7.1+maria~focal.
+
+        Examples
+        --------
+
+            if self.mysql_server_is(conn, (5, 6, 4)):
+                # do something for MySQL 5.6.4 and above
+
+        """
+        server_version = conn.get_server_info()
+        server_version_tuple = tuple(
+            (int(dig) if dig is not None else 0)
+            for dig in re.match(r'(\d+)\.(\d+)\.(\d+)', server_version).group(1, 2, 3)
+        )
+        return server_version_tuple >= version_tuple
+
+    _connections = None
+
+    @property
+    def connections(self):
+        if self._connections is None:
+            self._connections = []
+            for params in self.databases:
+                conn = sv.connect(**params)
+                self._connections.append(conn)
+            self.addCleanup(self._teardown_connections)
+        return self._connections
+
+    def connect(self, **params):
+        p = self.databases[0].copy()
+        p.update(params)
+        conn = sv.connect(**p)
+
+        @self.addCleanup
+        def teardown():
+            if conn.open:
+                conn.close()
+
+        return conn
+
+    def _teardown_connections(self):
+        if self._connections:
+            for connection in self._connections:
+                if connection.open:
+                    connection.close()
+            self._connections = None
+
+    def safe_create_table(self, connection, tablename, ddl, cleanup=True):
+        """
+        Create a table.
+
+        Ensures any existing version of that table is first dropped.
+
+        Also adds a cleanup rule to drop the table after the test
+        completes.
+
+        """
+        cursor = connection.cursor()
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore')
+            cursor.execute('drop table if exists `%s`' % (tablename,))
+        cursor.execute(ddl)
+        cursor.close()
+        if cleanup:
+            self.addCleanup(self.drop_table, connection, tablename)
+
+    def drop_table(self, connection, tablename):
+        cursor = connection.cursor()
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore')
+            cursor.execute('drop table if exists `%s`' % (tablename,))
+        cursor.close()