singlestoredb 1.16.1__py3-none-any.whl

singlestoredb/utils/convert_rows.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+"""Data value conversion utilities."""
+from typing import Any
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
+
+
+def convert_row(
+    values: Optional[Union[List[Any], Tuple[Any, ...]]],
+    converters: List[Any],
+) -> Optional[Tuple[Any, ...]]:
+    """
+    Convert a row of data values.
+
+    Parameters
+    ----------
+    values : tuple or None
+        Tuple containing values in a row of data
+    converters : list[tuple]
+        List of two-element tuples containing a column index and a converter
+        function. The column index specifies which column to apply the function to.
+
+    Returns
+    -------
+    tuple or None
+
+    """
+    if values is None:
+        return None
+    if not converters:
+        return tuple(values)
+    values = list(values)
+    for i, conv in enumerate(converters):
+        idx, encoding, func = conv
+        value = values[idx]
+        if encoding is not None and value is not None:
+            value = value.decode(encoding)
+        if func is not None:
+            values[idx] = func(value)
+        else:
+            values[idx] = value
+    return tuple(values)
+
+
+def convert_rows(rows: List[Any], converters: List[Any]) -> List[Any]:
+    """
+    Convert rows of data values.
+
+    Parameters
+    ----------
+    rows : list of tuples or None
+        Rows of data from a query
+    converters : list[tuple]
+        List of two-element tuples containing a column index and a converter
+        function. The column index specifies which column to apply the function to.
+
+    Returns
+    -------
+    list of tuples
+
+    """
+    if not rows or not converters:
+        return rows
+    rows = list(rows)
+    for i, row in enumerate(rows):
+        rows[i] = convert_row(row, converters=converters)
+    return rows

singlestoredb/utils/debug.py

@@ -0,0 +1,13 @@
+import sys
+from typing import Any
+
+from ..config import get_option
+
+
+def log_query(query: str, args: Any = None) -> None:
+    """Log the query and parameters."""
+    if get_option('debug.queries'):
+        if args is None:
+            print('[QUERY]', query, file=sys.stderr)
+        else:
+            print('[QUERY]', query, args, file=sys.stderr)

singlestoredb/utils/dtypes.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+
+try:
+    import numpy as np
+    has_numpy = True
+except ImportError:
+    has_numpy = False
+
+try:
+    import polars as pl
+    has_polars = True
+except ImportError:
+    has_polars = False
+
+try:
+    import pyarrow as pa
+    has_pyarrow = True
+except ImportError:
+    has_pyarrow = False
+
+
+DEFAULT_VALUES = {
+    0: 0,  # Decimal
+    1: 0,  # Tiny
+    -1: 0,  # Unsigned Tiny
+    2: 0,  # Short
+    -2: 0,  # Unsigned Short
+    3: 0,  # Long
+    -3: 0,  # Unsigned Long
+    4: float('nan'),  # Float
+    5: float('nan'),  # Double,
+    6: None,  # Null,
+    7: 0,  # Timestamp
+    8: 0,  # LongLong
+    -8: 0,  # Unsigned Longlong
+    9: 0,  # Int24
+    -9: 0,  # Unsigned Int24
+    10: 0,  # Date
+    -10: 0,  # Date
+    11: 0,  # Time
+    12: 0,  # Datetime
+    13: 0,  # Year
+    15: None,  # Varchar
+    -15: None,  # Varbinary
+    16: 0,  # Bit
+    245: None,  # JSON
+    246: 0,  # NewDecimal
+    -246: 0,  # NewDecimal
+    247: None,  # Enum
+    248: None,  # Set
+    249: None,  # TinyText
+    -249: None,  # TinyBlob
+    250: None,  # MediumText
+    -250: None,  # MediumBlob
+    251: None,  # LongText
+    -251: None,  # LongBlob
+    252: None,  # Text
+    -252: None,  # Blob
+    253: None,  # VarString
+    -253: None,  # VarBinary
+    254: None,  # String
+    -254: None,  # Binary
+    255: None,  # Geometry
+}
+
+
+if has_numpy:
+    NUMPY_TYPE_MAP = {
+        0: object,  # Decimal
+        1: np.int8,  # Tiny
+        -1: np.uint8,  # Unsigned Tiny
+        2: np.int16,  # Short
+        -2: np.uint16,  # Unsigned Short
+        3: np.int32,  # Long
+        -3: np.uint32,  # Unsigned Long
+        4: np.single,  # Float
+        5: np.double,  # Double,
+        6: object,  # Null,
+        7: np.dtype('datetime64[us]'),  # Timestamp
+        8: np.int64,  # LongLong
+        -8: np.uint64,  # Unsigned LongLong
+        9: np.int32,  # Int24
+        -9: np.uint32,  # Unsigned Int24
+        10: np.dtype('datetime64[D]'),  # Date
+        11: np.dtype('timedelta64[us]'),  # Time
+        12: np.dtype('datetime64[us]'),  # Datetime
+        13: np.int16,  # Year
+        15: object,  # Varchar
+        -15: object,  # Varbinary
+        16: object,  # Bit
+        245: object,  # JSON
+        246: object,  # NewDecimal
+        -246: object,  # NewDecimal
+        247: object,  # Enum
+        248: object,  # Set
+        249: object,  # TinyText
+        -249: object,  # TinyBlob
+        250: object,  # MediumText
+        -250: object,  # MediumBlob
+        251: object,  # LongText
+        -251: object,  # LongBlob
+        252: object,  # Blob
+        -252: object,  # Text
+        253: object,  # VarString
+        -253: object,  # VarBlob
+        254: object,  # String
+        -254: object,  # Binary
+        255: object,  # Geometry
+    }
+else:
+    NUMPY_TYPE_MAP = {}
+
+PANDAS_TYPE_MAP = NUMPY_TYPE_MAP
+
+if has_pyarrow:
+    PYARROW_TYPE_MAP = {
+        0: pa.decimal128(18, 6),  # Decimal
+        1: pa.int8(),  # Tiny
+        -1: pa.uint8(),  # Unsigned Tiny
+        2: pa.int16(),  # Short
+        -2: pa.uint16(),  # Unsigned Short
+        3: pa.int32(),  # Long
+        -3: pa.uint32(),  # Unsigned Long
+        4: pa.float32(),  # Float
+        5: pa.float64(),  # Double,
+        6: pa.null(),  # Null,
+        7: pa.timestamp('us'),  # Timestamp
+        8: pa.int64(),  # LongLong
+        -8: pa.uint64(),  # Unsigned LongLong
+        9: pa.int32(),  # Int24
+        -9: pa.uint32(),  # Unsigned Int24
+        10: pa.date64(),  # Date
+        11: pa.duration('us'),  # Time
+        12: pa.timestamp('us'),  # Datetime
+        13: pa.int16(),  # Year
+        15: pa.string(),  # Varchar
+        -15: pa.binary(),  # Varbinary
+        16: pa.binary(),  # Bit
+        245: pa.string(),  # JSON
+        246: pa.decimal128(18, 6),  # NewDecimal
+        -246: pa.decimal128(18, 6),  # NewDecimal
+        247: pa.string(),  # Enum
+        248: pa.string(),  # Set
+        249: pa.string(),  # TinyText
+        -249: pa.binary(),  # TinyBlob
+        250: pa.string(),  # MediumText
+        -250: pa.binary(),  # MediumBlob
+        251: pa.string(),  # LongText
+        -251: pa.binary(),  # LongBlob
+        252: pa.string(),  # Text
+        -252: pa.binary(),  # Blob
+        253: pa.string(),  # VarString
+        -253: pa.binary(),  # VarBinary
+        254: pa.string(),  # String
+        -254: pa.binary(),  # Binary
+        255: pa.string(),  # Geometry
+    }
+else:
+    PYARROW_TYPE_MAP = {}
+
+if has_polars:
+    POLARS_TYPE_MAP = {
+        0: pl.Decimal(10, 6),  # Decimal
+        1: pl.Int8,  # Tiny
+        -1: pl.UInt8,  # Unsigned Tiny
+        2: pl.Int16,  # Short
+        -2: pl.UInt16,  # Unsigned Short
+        3: pl.Int32,  # Long
+        -3: pl.UInt32,  # Unsigned Long
+        4: pl.Float32,  # Float
+        5: pl.Float64,  # Double,
+        6: pl.Null,  # Null,
+        7: pl.Datetime,  # Timestamp
+        8: pl.Int64,  # LongLong
+        -8: pl.UInt64,  # Unsigned LongLong
+        9: pl.Int32,  # Int24
+        -9: pl.UInt32,  # Unsigned Int24
+        10: pl.Date,  # Date
+        11: pl.Duration,  # Time
+        12: pl.Datetime,  # Datetime
+        13: pl.Int16,  # Year
+        15: pl.Utf8,  # Varchar
+        -15: pl.Utf8,  # Varbinary
+        16: pl.Binary,  # Bit
+        245: pl.Object,  # JSON
+        246: pl.Decimal(10, 6),  # NewDecimal
+        -246: pl.Decimal(10, 6),  # NewDecimal
+        247: pl.Utf8,  # Enum
+        248: pl.Utf8,  # Set
+        249: pl.Utf8,  # TinyText
+        -249: pl.Binary,  # TinyBlob
+        250: pl.Utf8,  # MediumBlob
+        -250: pl.Binary,  # MediumText
+        251: pl.Utf8,  # LongBlob
+        -251: pl.Binary,  # LongText
+        252: pl.Utf8,  # Blob
+        -252: pl.Binary,  # Text
+        253: pl.Utf8,  # VarString
+        -253: pl.Binary,  # VarBinary
+        254: pl.Utf8,  # String
+        -254: pl.Binary,  # Binary
+        255: pl.Utf8,  # Geometry
+    }
+else:
+    POLARS_TYPE_MAP = {}

singlestoredb/utils/events.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import Set
+
+try:
+    from IPython import get_ipython
+    has_ipython = True
+except ImportError:
+    has_ipython = False
+
+
+_subscribers: Set[Callable[[Dict[str, Any]], None]] = set()
+
+
+def subscribe(func: Callable[[Dict[str, Any]], None]) -> None:
+    """
+    Subscribe to SingleStore portal events.
+
+    Parameters
+    ----------
+    func : Callable
+        The function to call when an event is received
+
+    """
+    _subscribers.add(func)
+
+
+def unsubscribe(func: Callable[[Dict[str, Any]], None]) -> None:
+    """
+    Unsubscribe from SingleStore portal events.
+
+    Parameters
+    ----------
+    func : Callable
+        The function to call when an event is received
+
+    """
+    try:
+        _subscribers.remove(func)
+    except KeyError:
+        pass
+
+
+def _event_handler(stream: Any, ident: Any, msg: Dict[str, Any]) -> None:
+    """Handle request on the control stream."""
+    if not _subscribers or not isinstance(msg, dict):
+        return
+
+    content = msg.get('content', {})
+    if content.get('type', '') != 'event':
+        return
+
+    for func in _subscribers:
+        func(content)
+
+
+# Inject a control handler to receive SingleStore events
+if has_ipython:
+    try:
+        _handlers = get_ipython().kernel.control_handlers
+        _handlers['singlestore_portal_request'] = _event_handler
+    except AttributeError:
+        pass

singlestoredb/utils/mogrify.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+from collections.abc import Sequence
+from typing import Any
+from typing import Dict
+from typing import Optional
+from typing import Union
+
+from ..mysql import converters
+from ..mysql.constants import SERVER_STATUS
+
+
+Encoders = converters.Encoders
+
+
+def escape(
+    obj: Any,
+    charset: str = 'utf8',
+    mapping: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> str:
+    """
+    Escape whatever value is passed.
+
+    Non-standard, for internal use; do not use this in your applications.
+
+    """
+    dtype = type(obj)
+    if dtype is str or isinstance(obj, str):
+        return "'{}'".format(escape_string(obj, server_status=server_status))
+    if dtype is bytes or dtype is bytearray or isinstance(obj, (bytes, bytearray)):
+        return _quote_bytes(
+            obj,
+            server_status=server_status,
+            binary_prefix=binary_prefix,
+        )
+    if mapping is None:
+        mapping = converters.encoders
+    return converters.escape_item(obj, charset, mapping=mapping)
+
+
+def literal(
+    obj: Any,
+    charset: str = 'utf8',
+    encoders: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> str:
+    """
+    Alias for escape().
+
+    Non-standard, for internal use; do not use this in your applications.
+
+    """
+    return escape(
+        obj, charset=charset, mapping=encoders,
+        server_status=server_status, binary_prefix=binary_prefix,
+    )
+
+
+def escape_string(
+    s: str,
+    server_status: int = 0,
+) -> str:
+    """Escape a string value."""
+    if server_status & SERVER_STATUS.SERVER_STATUS_NO_BACKSLASH_ESCAPES:
+        return s.replace("'", "''")
+    return converters.escape_string(s)
+
+
+def _quote_bytes(
+    s: bytes,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> str:
+    if server_status & SERVER_STATUS.SERVER_STATUS_NO_BACKSLASH_ESCAPES:
+        if binary_prefix:
+            return "_binary X'{}'".format(s.hex())
+        return "X'{}'".format(s.hex())
+    return converters.escape_bytes(s)
+
+
+def _escape_args(
+    args: Union[Sequence[Any], Dict[str, Any], None],
+    charset: str = 'utf8',
+    encoders: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> Any:
+    if encoders is None:
+        encoders = converters.encoders
+
+    if isinstance(args, (tuple, list)):
+        return tuple(
+            literal(
+                arg, charset=charset, encoders=encoders,
+                server_status=server_status,
+                binary_prefix=binary_prefix,
+            ) for arg in args
+        )
+
+    elif isinstance(args, dict):
+        return {
+            key: literal(
+                val, charset=charset, encoders=encoders,
+                server_status=server_status,
+                binary_prefix=binary_prefix,
+            ) for (key, val) in args.items()
+        }
+
+    # If it's not a dictionary let's try escaping it anyways.
+    # Worst case it will throw a Value error
+    return escape(
+        args, charset=charset, mapping=encoders,
+        server_status=server_status, binary_prefix=binary_prefix,
+    )
+
+
+def mogrify(
+    query: Union[str, bytes],
+    args: Union[Sequence[Any], Dict[str, Any], None] = None,
+    charset: str = 'utf8',
+    encoders: Optional[Encoders] = None,
+    server_status: int = 0,
+    binary_prefix: bool = False,
+) -> Union[str, bytes]:
+    """
+    Returns the exact string sent to the database by calling the execute() method.
+
+    This method follows the extension to the DB API 2.0 followed by Psycopg.
+
+    Parameters
+    ----------
+    query : str
+        Query to mogrify.
+    args : Sequence[Any] or Dict[str, Any] or Any, optional
+        Parameters used with query. (optional)
+
+    Returns
+    -------
+    str : The query with argument binding applied.
+
+    """
+    if args:
+        query = query % _escape_args(
+            args, charset=charset,
+            encoders=encoders,
+            server_status=server_status,
+            binary_prefix=binary_prefix,
+        )
+    return query