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

singlestoredb/clients/pymysqlsv/converters.py

@@ -1,365 +0,0 @@
-# type: ignore
-import datetime
-import re
-import time
-from decimal import Decimal
-
-from .constants import FIELD_TYPE
-from .err import ProgrammingError
-
-
-def escape_item(val, charset, mapping=None):
-    if mapping is None:
-        mapping = encoders
-    encoder = mapping.get(type(val))
-
-    # Fallback to default when no encoder found
-    if not encoder:
-        try:
-            encoder = mapping[str]
-        except KeyError:
-            raise TypeError('no default type converter defined')
-
-    if encoder in (escape_dict, escape_sequence):
-        val = encoder(val, charset, mapping)
-    else:
-        val = encoder(val, mapping)
-    return val
-
-
-def escape_dict(val, charset, mapping=None):
-    n = {}
-    for k, v in val.items():
-        quoted = escape_item(v, charset, mapping)
-        n[k] = quoted
-    return n
-
-
-def escape_sequence(val, charset, mapping=None):
-    n = []
-    for item in val:
-        quoted = escape_item(item, charset, mapping)
-        n.append(quoted)
-    return '(' + ','.join(n) + ')'
-
-
-def escape_set(val, charset, mapping=None):
-    return ','.join([escape_item(x, charset, mapping) for x in val])
-
-
-def escape_bool(value, mapping=None):
-    return str(int(value))
-
-
-def escape_int(value, mapping=None):
-    return str(value)
-
-
-def escape_float(value, mapping=None):
-    s = repr(value)
-    if s in ('inf', 'nan'):
-        raise ProgrammingError('%s can not be used with MySQL' % s)
-    if 'e' not in s:
-        s += 'e0'
-    return s
-
-
-_escape_table = [chr(x) for x in range(128)]
-_escape_table[0] = '\\0'
-_escape_table[ord('\\')] = '\\\\'
-_escape_table[ord('\n')] = '\\n'
-_escape_table[ord('\r')] = '\\r'
-_escape_table[ord('\032')] = '\\Z'
-_escape_table[ord('"')] = '\\"'
-_escape_table[ord("'")] = "\\'"
-
-
-def escape_string(value, mapping=None):
-    """escapes *value* without adding quote.
-
-    Value should be unicode
-    """
-    return value.translate(_escape_table)
-
-
-def escape_bytes_prefixed(value, mapping=None):
-    return "_binary'%s'" % value.decode('ascii', 'surrogateescape').translate(
-        _escape_table,
-    )
-
-
-def escape_bytes(value, mapping=None):
-    return "'%s'" % value.decode('ascii', 'surrogateescape').translate(_escape_table)
-
-
-def escape_str(value, mapping=None):
-    return "'%s'" % escape_string(str(value), mapping)
-
-
-def escape_None(value, mapping=None):
-    return 'NULL'
-
-
-def escape_timedelta(obj, mapping=None):
-    seconds = int(obj.seconds) % 60
-    minutes = int(obj.seconds // 60) % 60
-    hours = int(obj.seconds // 3600) % 24 + int(obj.days) * 24
-    if obj.microseconds:
-        fmt = "'{0:02d}:{1:02d}:{2:02d}.{3:06d}'"
-    else:
-        fmt = "'{0:02d}:{1:02d}:{2:02d}'"
-    return fmt.format(hours, minutes, seconds, obj.microseconds)
-
-
-def escape_time(obj, mapping=None):
-    if obj.microsecond:
-        fmt = "'{0.hour:02}:{0.minute:02}:{0.second:02}.{0.microsecond:06}'"
-    else:
-        fmt = "'{0.hour:02}:{0.minute:02}:{0.second:02}'"
-    return fmt.format(obj)
-
-
-def escape_datetime(obj, mapping=None):
-    if obj.microsecond:
-        fmt = "'{0.year:04}-{0.month:02}-{0.day:02} {0.hour:02}:{0.minute:02}:{0.second:02}.{0.microsecond:06}'"
-    else:
-        fmt = "'{0.year:04}-{0.month:02}-{0.day:02} {0.hour:02}:{0.minute:02}:{0.second:02}'"
-    return fmt.format(obj)
-
-
-def escape_date(obj, mapping=None):
-    fmt = "'{0.year:04}-{0.month:02}-{0.day:02}'"
-    return fmt.format(obj)
-
-
-def escape_struct_time(obj, mapping=None):
-    return escape_datetime(datetime.datetime(*obj[:6]))
-
-
-def Decimal2Literal(o, d):
-    return format(o, 'f')
-
-
-def _convert_second_fraction(s):
-    if not s:
-        return 0
-    # Pad zeros to ensure the fraction length in microseconds
-    s = s.ljust(6, '0')
-    return int(s[:6])
-
-
-DATETIME_RE = re.compile(
-    r'(\d{1,4})-(\d{1,2})-(\d{1,2})[T ](\d{1,2}):(\d{1,2}):(\d{1,2})(?:.(\d{1,6}))?',
-)
-
-
-def convert_datetime(obj):
-    """Returns a DATETIME or TIMESTAMP column value as a datetime object:
-
-      >>> convert_datetime('2007-02-25 23:06:20')
-      datetime.datetime(2007, 2, 25, 23, 6, 20)
-      >>> convert_datetime('2007-02-25T23:06:20')
-      datetime.datetime(2007, 2, 25, 23, 6, 20)
-
-    Illegal values are returned as str:
-
-      >>> convert_datetime('2007-02-31T23:06:20')
-      '2007-02-31T23:06:20'
-      >>> convert_datetime('0000-00-00 00:00:00')
-      '0000-00-00 00:00:00'
-    """
-    if isinstance(obj, (bytes, bytearray)):
-        obj = obj.decode('ascii')
-
-    m = DATETIME_RE.match(obj)
-    if not m:
-        return convert_date(obj)
-
-    try:
-        groups = list(m.groups())
-        groups[-1] = _convert_second_fraction(groups[-1])
-        return datetime.datetime(*[int(x) for x in groups])
-    except ValueError:
-        return convert_date(obj)
-
-
-TIMEDELTA_RE = re.compile(r'(-)?(\d{1,3}):(\d{1,2}):(\d{1,2})(?:.(\d{1,6}))?')
-
-
-def convert_timedelta(obj):
-    """Returns a TIME column as a timedelta object:
-
-      >>> convert_timedelta('25:06:17')
-      datetime.timedelta(days=1, seconds=3977)
-      >>> convert_timedelta('-25:06:17')
-      datetime.timedelta(days=-2, seconds=82423)
-
-    Illegal values are returned as string:
-
-      >>> convert_timedelta('random crap')
-      'random crap'
-
-    Note that MySQL always returns TIME columns as (+|-)HH:MM:SS, but
-    can accept values as (+|-)DD HH:MM:SS. The latter format will not
-    be parsed correctly by this function.
-    """
-    if isinstance(obj, (bytes, bytearray)):
-        obj = obj.decode('ascii')
-
-    m = TIMEDELTA_RE.match(obj)
-    if not m:
-        return obj
-
-    try:
-        groups = list(m.groups())
-        groups[-1] = _convert_second_fraction(groups[-1])
-        negate = -1 if groups[0] else 1
-        hours, minutes, seconds, microseconds = groups[1:]
-
-        tdelta = (
-            datetime.timedelta(
-                hours=int(hours),
-                minutes=int(minutes),
-                seconds=int(seconds),
-                microseconds=int(microseconds),
-            )
-            * negate
-        )
-        return tdelta
-    except ValueError:
-        return obj
-
-
-TIME_RE = re.compile(r'(\d{1,2}):(\d{1,2}):(\d{1,2})(?:.(\d{1,6}))?')
-
-
-def convert_time(obj):
-    """Returns a TIME column as a time object:
-
-      >>> convert_time('15:06:17')
-      datetime.time(15, 6, 17)
-
-    Illegal values are returned as str:
-
-      >>> convert_time('-25:06:17')
-      '-25:06:17'
-      >>> convert_time('random crap')
-      'random crap'
-
-    Note that MySQL always returns TIME columns as (+|-)HH:MM:SS, but
-    can accept values as (+|-)DD HH:MM:SS. The latter format will not
-    be parsed correctly by this function.
-
-    Also note that MySQL's TIME column corresponds more closely to
-    Python's timedelta and not time. However if you want TIME columns
-    to be treated as time-of-day and not a time offset, then you can
-    use set this function as the converter for FIELD_TYPE.TIME.
-    """
-    if isinstance(obj, (bytes, bytearray)):
-        obj = obj.decode('ascii')
-
-    m = TIME_RE.match(obj)
-    if not m:
-        return obj
-
-    try:
-        groups = list(m.groups())
-        groups[-1] = _convert_second_fraction(groups[-1])
-        hours, minutes, seconds, microseconds = groups
-        return datetime.time(
-            hour=int(hours),
-            minute=int(minutes),
-            second=int(seconds),
-            microsecond=int(microseconds),
-        )
-    except ValueError:
-        return obj
-
-
-def convert_date(obj):
-    """Returns a DATE column as a date object:
-
-      >>> convert_date('2007-02-26')
-      datetime.date(2007, 2, 26)
-
-    Illegal values are returned as str:
-
-      >>> convert_date('2007-02-31')
-      '2007-02-31'
-      >>> convert_date('0000-00-00')
-      '0000-00-00'
-    """
-    if isinstance(obj, (bytes, bytearray)):
-        obj = obj.decode('ascii')
-    try:
-        return datetime.date(*[int(x) for x in obj.split('-', 2)])
-    except ValueError:
-        return obj
-
-
-def through(x):
-    return x
-
-
-# def convert_bit(b):
-#    b = "\x00" * (8 - len(b)) + b # pad w/ zeroes
-#    return struct.unpack(">Q", b)[0]
-#
-#     the snippet above is right, but MySQLdb doesn't process bits,
-#     so we shouldn't either
-convert_bit = through
-
-
-encoders = {
-    bool: escape_bool,
-    int: escape_int,
-    float: escape_float,
-    str: escape_str,
-    bytes: escape_bytes,
-    tuple: escape_sequence,
-    list: escape_sequence,
-    set: escape_sequence,
-    frozenset: escape_sequence,
-    dict: escape_dict,
-    type(None): escape_None,
-    datetime.date: escape_date,
-    datetime.datetime: escape_datetime,
-    datetime.timedelta: escape_timedelta,
-    datetime.time: escape_time,
-    time.struct_time: escape_struct_time,
-    Decimal: Decimal2Literal,
-}
-
-
-decoders = {
-    FIELD_TYPE.BIT: convert_bit,
-    FIELD_TYPE.TINY: int,
-    FIELD_TYPE.SHORT: int,
-    FIELD_TYPE.LONG: int,
-    FIELD_TYPE.FLOAT: float,
-    FIELD_TYPE.DOUBLE: float,
-    FIELD_TYPE.LONGLONG: int,
-    FIELD_TYPE.INT24: int,
-    FIELD_TYPE.YEAR: int,
-    FIELD_TYPE.TIMESTAMP: convert_datetime,
-    FIELD_TYPE.DATETIME: convert_datetime,
-    FIELD_TYPE.TIME: convert_timedelta,
-    FIELD_TYPE.DATE: convert_date,
-    FIELD_TYPE.BLOB: through,
-    FIELD_TYPE.TINY_BLOB: through,
-    FIELD_TYPE.MEDIUM_BLOB: through,
-    FIELD_TYPE.LONG_BLOB: through,
-    FIELD_TYPE.STRING: through,
-    FIELD_TYPE.VAR_STRING: through,
-    FIELD_TYPE.VARCHAR: through,
-    FIELD_TYPE.DECIMAL: Decimal,
-    FIELD_TYPE.NEWDECIMAL: Decimal,
-}
-
-
-# for MySQLdb compatibility
-conversions = encoders.copy()
-conversions.update(decoders)
-Thing2Literal = escape_str
-
-# Run doctests with `pytest --doctest-modules pymysql/converters.py`

singlestoredb/clients/pymysqlsv/err.py

@@ -1,144 +0,0 @@
-# type: ignore
-import struct
-
-from .constants import ER
-
-
-class MySQLError(Exception):
-    """Exception related to operation with MySQL."""
-
-
-class Warning(Warning, MySQLError):
-    """Exception raised for important warnings like data truncations
-    while inserting, etc."""
-
-
-class Error(MySQLError):
-    """Exception that is the base class of all other error exceptions
-    (not Warning)."""
-
-
-class InterfaceError(Error):
-    """Exception raised for errors that are related to the database
-    interface rather than the database itself."""
-
-
-class DatabaseError(Error):
-    """Exception raised for errors that are related to the
-    database."""
-
-
-class DataError(DatabaseError):
-    """Exception raised for errors that are due to problems with the
-    processed data like division by zero, numeric value out of range,
-    etc."""
-
-
-class OperationalError(DatabaseError):
-    """Exception raised for errors that are related to the database's
-    operation and not necessarily under the control of the programmer,
-    e.g. an unexpected disconnect occurs, the data source name is not
-    found, a transaction could not be processed, a memory allocation
-    error occurred during processing, etc."""
-
-
-class IntegrityError(DatabaseError):
-    """Exception raised when the relational integrity of the database
-    is affected, e.g. a foreign key check fails, duplicate key,
-    etc."""
-
-
-class InternalError(DatabaseError):
-    """Exception raised when the database encounters an internal
-    error, e.g. the cursor is not valid anymore, the transaction is
-    out of sync, etc."""
-
-
-class ProgrammingError(DatabaseError):
-    """Exception raised for programming errors, e.g. table not found
-    or already exists, syntax error in the SQL statement, wrong number
-    of parameters specified, etc."""
-
-
-class NotSupportedError(DatabaseError):
-    """Exception raised in case a method or database API was used
-    which is not supported by the database, e.g. requesting a
-    .rollback() on a connection that does not support transaction or
-    has transactions turned off."""
-
-
-error_map = {}
-
-
-def _map_error(exc, *errors):
-    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):
-    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/tests/__init__.py

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

singlestoredb/clients/pymysqlsv/tests/test_cursor.py

@@ -1,133 +0,0 @@
-# type: ignore
-import warnings
-
-import singlestoredb.clients.pymysqlsv as sv
-import singlestoredb.clients.pymysqlsv.cursors as cursors
-from singlestoredb.clients.pymysqlsv.tests import base
-
-
-class CursorTest(base.PyMySQLTestCase):
-    def setUp(self):
-        super(CursorTest, self).setUp()
-
-        conn = self.connect()
-        self.safe_create_table(
-            conn,
-            'test',
-            'create table test (data varchar(10))',
-        )
-        cursor = conn.cursor()
-        cursor.execute(
-            'insert into test (data) values '
-            "('row1'), ('row2'), ('row3'), ('row4'), ('row5')",
-        )
-        cursor.close()
-        self.test_connection = sv.connect(**self.databases[0])
-        self.addCleanup(self.test_connection.close)
-
-    def test_cleanup_rows_unbuffered(self):
-        conn = self.test_connection
-        cursor = conn.cursor(cursors.SSCursor)
-
-        cursor.execute('select * from test as t1, test as t2')
-        for counter, row in enumerate(cursor):
-            if counter > 10:
-                break
-
-        del cursor
-
-        c2 = conn.cursor()
-
-        c2.execute('select 1')
-        self.assertEqual(c2.fetchone(), (1,))
-        self.assertIsNone(c2.fetchone())
-
-    def test_cleanup_rows_buffered(self):
-        conn = self.test_connection
-        cursor = conn.cursor(cursors.Cursor)
-
-        cursor.execute('select * from test as t1, test as t2')
-        for counter, row in enumerate(cursor):
-            if counter > 10:
-                break
-
-        del cursor
-
-        c2 = conn.cursor()
-        c2.execute('select 1')
-
-        self.assertEqual(c2.fetchone(), (1,))
-        self.assertIsNone(c2.fetchone())
-
-    def test_executemany(self):
-        conn = self.test_connection
-        cursor = conn.cursor(cursors.Cursor)
-
-        m = cursors.RE_INSERT_VALUES.match(
-            'INSERT INTO TEST (ID, NAME) VALUES (%s, %s)',
-        )
-        self.assertIsNotNone(m, 'error parse %s')
-        self.assertEqual(m.group(3), '', 'group 3 not blank, bug in RE_INSERT_VALUES?')
-
-        m = cursors.RE_INSERT_VALUES.match(
-            'INSERT INTO TEST (ID, NAME) VALUES (%(id)s, %(name)s)',
-        )
-        self.assertIsNotNone(m, 'error parse %(name)s')
-        self.assertEqual(m.group(3), '', 'group 3 not blank, bug in RE_INSERT_VALUES?')
-
-        m = cursors.RE_INSERT_VALUES.match(
-            'INSERT INTO TEST (ID, NAME) VALUES (%(id_name)s, %(name)s)',
-        )
-        self.assertIsNotNone(m, 'error parse %(id_name)s')
-        self.assertEqual(m.group(3), '', 'group 3 not blank, bug in RE_INSERT_VALUES?')
-
-        m = cursors.RE_INSERT_VALUES.match(
-            'INSERT INTO TEST (ID, NAME) VALUES (%(id_name)s, %(name)s) ON duplicate update',
-        )
-        self.assertIsNotNone(m, 'error parse %(id_name)s')
-        self.assertEqual(
-            m.group(3),
-            ' ON duplicate update',
-            'group 3 not ON duplicate update, bug in RE_INSERT_VALUES?',
-        )
-
-        # https://github.com/PyMySQL/PyMySQL/pull/597
-        m = cursors.RE_INSERT_VALUES.match(
-            'INSERT INTO bloup(foo, bar)VALUES(%s, %s)',
-        )
-        assert m is not None
-
-        # cursor._executed must bee "insert into test (data) values (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)"
-        # list args
-        data = range(10)
-        cursor.executemany('insert into test (data) values (%s)', data)
-        self.assertTrue(
-            cursor._executed.endswith(b',(7),(8),(9)'),
-            'execute many with %s not in one query',
-        )
-
-        # dict args
-        data_dict = [{'data': i} for i in range(10)]
-        cursor.executemany('insert into test (data) values (%(data)s)', data_dict)
-        self.assertTrue(
-            cursor._executed.endswith(b',(7),(8),(9)'),
-            'execute many with %(data)s not in one query',
-        )
-
-        # %% in column set
-        cursor.execute(
-            """\
-            CREATE TABLE percent_test (
-                `A%` INTEGER,
-                `B%` INTEGER)""",
-        )
-        try:
-            q = 'INSERT INTO percent_test (`A%%`, `B%%`) VALUES (%s, %s)'
-            self.assertIsNotNone(cursors.RE_INSERT_VALUES.match(q))
-            cursor.executemany(q, [(3, 4), (5, 6)])
-            self.assertTrue(
-                cursor._executed.endswith(b'(3, 4),(5, 6)'),
-                'executemany with %% not in one query',
-            )
-        finally:
-            cursor.execute('DROP TABLE IF EXISTS percent_test')

singlestoredb/clients/pymysqlsv/tests/thirdparty/test_MySQLdb/__init__.py

@@ -1,9 +0,0 @@
-# type: ignore
-from .test_MySQLdb_capabilities import test_MySQLdb as test_capabilities
-from .test_MySQLdb_dbapi20 import test_MySQLdb as test_dbapi2
-from .test_MySQLdb_nonstandard import *
-
-if __name__ == '__main__':
-    import unittest
-
-    unittest.main()