singlestoredb 0.4.0__py3-none-any.whl → 1.0.4__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/{clients/pymysqlsv → mysql}/optionfile.py

@@ -1,19 +1,20 @@
-# type: ignore
 import configparser
+from typing import Any
 
 
 class Parser(configparser.RawConfigParser):
-    def __init__(self, **kwargs):
+
+    def __init__(self, **kwargs: Any) -> None:
         kwargs['allow_no_value'] = True
         configparser.RawConfigParser.__init__(self, **kwargs)
 
-    def __remove_quotes(self, value):
+    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, option):
+    def get(self, section: str, option: str) -> str:  # type: ignore
         value = configparser.RawConfigParser.get(self, section, option)
         return self.__remove_quotes(value)

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

@@ -5,12 +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
@@ -20,6 +22,7 @@ UNSIGNED_INT64_COLUMN = 254
 
 
 def dump_packet(data):  # pragma: no cover
+
     def printable(data):
         if 32 <= data < 127:
             return chr(data)
@@ -46,9 +49,11 @@ def dump_packet(data):  # pragma: no cover
 
 
 class MysqlPacket:
-    """Representation of a MySQL response packet.
+    """
+    Representation of a MySQL response packet.
 
     Provides an interface for reading/parsing the packet results.
+
     """
 
     __slots__ = ('_position', '_data')
@@ -77,16 +82,18 @@ class MysqlPacket:
         return result
 
     def read_all(self):
-        """Read all remaining data in the packet.
+        """
+        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."""
+        """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(
@@ -102,13 +109,15 @@ class MysqlPacket:
         self._position = position
 
     def get_bytes(self, position, length=1):
-        """Get 'length' bytes starting at 'position'.
+        """
+        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)]
 
@@ -146,10 +155,12 @@ class MysqlPacket:
         return result
 
     def read_length_encoded_integer(self):
-        """Read a 'Length Coded Binary' number from the data buffer.
+        """
+        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:
@@ -164,11 +175,13 @@ class MysqlPacket:
             return self.read_uint64()
 
     def read_length_coded_string(self):
-        """Read a 'Length Coded String' from the data buffer.
+        """
+        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:
@@ -226,10 +239,12 @@ class MysqlPacket:
 
 
 class FieldDescriptorPacket(MysqlPacket):
-    """A MysqlPacket that represents a specific column's metadata in the result.
+    """
+    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):
@@ -237,9 +252,11 @@ class FieldDescriptorPacket(MysqlPacket):
         self._parse_field_descriptor(encoding)
 
     def _parse_field_descriptor(self, encoding):
-        """Parse the 'Field Descriptor' (Metadata) packet.
+        """
+        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()
@@ -259,7 +276,7 @@ class FieldDescriptorPacket(MysqlPacket):
 
     def description(self):
         """Provides a 7-item tuple compatible with the Python PEP249 DB Spec."""
-        return (
+        return Description(
             self.name,
             self.type_code,
             None,  # TODO: display_length; should this be self.length?
@@ -267,6 +284,8 @@ class FieldDescriptorPacket(MysqlPacket):
             self.get_column_length(),  # 'precision'  # TODO: why!?!?
             self.scale,
             self.flags % 2 == 0,
+            self.flags,
+            self.charsetnr,
         )
 
     def get_column_length(self):
@@ -276,21 +295,25 @@ class FieldDescriptorPacket(MysqlPacket):
         return self.length
 
     def __str__(self):
-        return '%s %r.%r.%r, type=%s, flags=%x' % (
+        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.
+    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):
@@ -316,9 +339,12 @@ class OKPacketWrapper:
 
 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.
+    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):
@@ -339,9 +365,12 @@ class EOFPacketWrapper:
 
 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.
+    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):

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/{clients/pymysqlsv → mysql}/tests/base.py

@@ -1,12 +1,19 @@
 # type: ignore
-import gc
 import json
 import os
+import platform
 import re
 import unittest
 import warnings
 
-import singlestoredb.clients.pymysqlsv as sv
+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):
@@ -17,31 +24,41 @@ class PyMySQLTestCase(unittest.TestCase):
         with open(fname) as f:
             databases = json.load(f)
     else:
+        params = build_params()
         databases = [
             {
-                'host': 'localhost',
-                'user': 'root',
-                'passwd': '',
-                'database': 'test1',
+                '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'],
             },
-            {'host': 'localhost', 'user': 'root', 'passwd': '', 'database': 'test2'},
         ]
 
     def mysql_server_is(self, conn, version_tuple):
-        """Return True if the given connection is on the version given or
-        greater.
+        """
+        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.
 
-        e.g.::
+        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(
@@ -57,7 +74,8 @@ class PyMySQLTestCase(unittest.TestCase):
         if self._connections is None:
             self._connections = []
             for params in self.databases:
-                self._connections.append(sv.connect(**params))
+                conn = sv.connect(**params)
+                self._connections.append(conn)
             self.addCleanup(self._teardown_connections)
         return self._connections
 
@@ -81,12 +99,14 @@ class PyMySQLTestCase(unittest.TestCase):
             self._connections = None
 
     def safe_create_table(self, connection, tablename, ddl, cleanup=True):
-        """create a table.
+        """
+        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()
 

singlestoredb/mysql/tests/conftest.py

@@ -0,0 +1,37 @@
+import platform
+
+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(),
+              )
+
+
+def pytest_sessionstart() -> None:
+    params = build_params()
+    conn = sv.connect(  # type: ignore
+        host=params['host'], user=params['user'],
+        passwd=params['password'], port=params['port'],
+        buffered=params['buffered'],
+    )
+    cur = conn.cursor()
+    cur.execute(f'CREATE DATABASE IF NOT EXISTS {DBNAME_BASE}1')
+    cur.execute(f'CREATE DATABASE IF NOT EXISTS {DBNAME_BASE}2')
+    conn.close()
+
+
+def pytest_sessionfinish() -> None:
+    params = build_params()
+    conn = sv.connect(  # type: ignore
+        host=params['host'], user=params['user'],
+        passwd=params['password'], port=params['port'],
+        buffered=params['buffered'],
+    )
+    cur = conn.cursor()
+    cur.execute(f'DROP DATABASE {DBNAME_BASE}1')
+    cur.execute(f'DROP DATABASE {DBNAME_BASE}2')
+    conn.close()

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_DictCursor.py

@@ -2,11 +2,14 @@
 import datetime
 import warnings
 
-import singlestoredb.clients.pymysqlsv.cursors as cursors
-from singlestoredb.clients.pymysqlsv.tests import base
+import pytest
+
+import singlestoredb.mysql.cursors as cursors
+from singlestoredb.mysql.tests import base
 
 
 class TestDictCursor(base.PyMySQLTestCase):
+
     bob = {'name': 'bob', 'age': 21, 'DOB': datetime.datetime(1990, 2, 6, 23, 4, 56)}
     jim = {'name': 'jim', 'age': 56, 'DOB': datetime.datetime(1955, 5, 9, 13, 12, 45)}
     fred = {'name': 'fred', 'age': 100, 'DOB': datetime.datetime(1911, 9, 12, 1, 1, 1)}
@@ -15,15 +18,15 @@ class TestDictCursor(base.PyMySQLTestCase):
 
     def setUp(self):
         super(TestDictCursor, self).setUp()
-        self.conn = conn = self.connect()
-        c = conn.cursor(self.cursor_type)
+        self.conn = conn = self.connect(cursorclass=self.cursor_type)
+        c = conn.cursor()
 
         # create a table ane some data to query
         with warnings.catch_warnings():
             warnings.filterwarnings('ignore')
             c.execute('drop table if exists dictcursor')
-            # include in filterwarnings since for unbuffered dict cursor warning for lack of table
-            # will only be propagated at start of next execute() call
+            # include in filterwarnings since for unbuffered dict cursor warning
+            # for lack of table will only be propagated at start of next execute() call
             c.execute(
                 """CREATE TABLE dictcursor (name char(20), age int , DOB datetime)""",
             )
@@ -46,7 +49,7 @@ class TestDictCursor(base.PyMySQLTestCase):
         bob, jim, fred = self.bob.copy(), self.jim.copy(), self.fred.copy()
         # all assert test compare to the structure as would come out from MySQLdb
         conn = self.conn
-        c = conn.cursor(self.cursor_type)
+        c = conn.cursor()
 
         # try an update which should return no rows
         c.execute("update dictcursor set age=20 where name='bob'")
@@ -83,6 +86,7 @@ class TestDictCursor(base.PyMySQLTestCase):
         self.assertEqual([bob, fred], r, 'fetchmany failed via DictCursor')
         self._ensure_cursor_expired(c)
 
+    @pytest.mark.skip('Custom cursors are only available when creating a connection')
     def test_custom_dict(self):
         class MyDict(dict):
             pass

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_SSCursor.py

@@ -2,24 +2,29 @@
 import sys
 
 try:
-    import singlestoredb.clients.pymysqlsv as sv
-    from singlestoredb.clients.pymysqlsv.tests import base
-    import singlestoredb.clients.pymysqlsv.cursors as cursors
-    from singlestoredb.clients.pymysqlsv.constants import CLIENT
+    import singlestoredb.mysql as sv
+    from singlestoredb.mysql.tests import base
+    import singlestoredb.mysql.cursors as cursors
+    from singlestoredb.mysql.constants import CLIENT
 except Exception:
     # For local testing from top-level directory, without installing
-    sys.path.append('../pymysqlsv')
-    import singlestoredb.clients.pymysqlsv as sv
-    from singlestoredb.clients.pymysqlsv.tests import base
-    import singlestoredb.clients.pymysqlsv.cursors as cursors
-    from singlestoredb.clients.pymysqlsv.constants import CLIENT
+    sys.path.append('../../..')
+    import singlestoredb.mysql as sv  # noqa: F401
+    from singlestoredb.mysql.tests import base
+    import singlestoredb.mysql.cursors as cursors
+    from singlestoredb.mysql.constants import CLIENT
 
 
 class TestSSCursor(base.PyMySQLTestCase):
+
     def test_SSCursor(self):
-        affected_rows = 18446744073709551615
+        # affected_rows = 18446744073709551615
+        affected_rows = -1
 
-        conn = self.connect(client_flag=CLIENT.MULTI_STATEMENTS)
+        conn = self.connect(
+            client_flag=CLIENT.MULTI_STATEMENTS,
+            cursorclass=cursors.SSCursor,
+        )
         data = [
             ('America', '', 'America/Jamaica'),
             ('America', '', 'America/Los_Angeles'),
@@ -33,7 +38,7 @@ class TestSSCursor(base.PyMySQLTestCase):
             ('America', '', 'America/Detroit'),
         ]
 
-        cursor = conn.cursor(cursors.SSCursor)
+        cursor = conn.cursor()
 
         cursor.execute('DROP TABLE IF EXISTS tz_data')