pyoq-sql 1.0.2__py3-none-any.whl

pyoq/schema/mysql/dsn.py

@@ -0,0 +1,72 @@
+"""MySQL data source name parsing."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urllib.parse import SplitResult, unquote, urlsplit
+
+from pyoq.errors import ConfigurationValidationError
+
+DEFAULT_PORT = 3306
+SCHEME = "mysql"
+
+
+@dataclass(frozen=True, slots=True)
+class MySQLConnectionSettings:
+    host: str
+    port: int
+    user: str
+    password: str
+    database: str
+
+
+def parse_data_source_name(dsn: str) -> MySQLConnectionSettings:
+    parts = urlsplit(dsn)
+    if parts.scheme != SCHEME:
+        message = f"MySQL data source names must use the {SCHEME} scheme"
+        raise ConfigurationValidationError(message)
+    if parts.query or parts.fragment:
+        message = (
+            "MySQL data source names do not accept query or fragment options; "
+            "supply host, port, user, password, and database only"
+        )
+        raise ConfigurationValidationError(message)
+    return MySQLConnectionSettings(
+        host=parts.hostname or "localhost",
+        port=_port(parts),
+        user=_user(parts.username),
+        password=unquote(parts.password or ""),
+        database=_database(parts.path),
+    )
+
+
+def _port(parts: SplitResult) -> int:
+    try:
+        port = parts.port
+    except ValueError as error:
+        message = f"MySQL data source name has an invalid port: {error}"
+        raise ConfigurationValidationError(message) from error
+    return DEFAULT_PORT if port is None else port
+
+
+def _user(value: str | None) -> str:
+    user = unquote(value or "")
+    if user == "":
+        message = "MySQL data source names must name a user"
+        raise ConfigurationValidationError(message)
+    return user
+
+
+def _database(path: str) -> str:
+    if not path.startswith("/") or path.count("/") != 1 or path == "/":
+        message = "MySQL data source names must name exactly one database"
+        raise ConfigurationValidationError(message)
+    return unquote(path[1:])
+
+
+__all__ = (
+    "DEFAULT_PORT",
+    "SCHEME",
+    "MySQLConnectionSettings",
+    "parse_data_source_name",
+)

pyoq/schema/mysql/records.py

@@ -0,0 +1,354 @@
+"""Typed MySQL information schema row records."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pyoq.errors import SchemaInspectionError
+from pyoq.schema.models import (
+    GeneratedKind,
+    GeneratedValue,
+    Identifier,
+    IndexTerm,
+    KeyKind,
+    ObjectReference,
+    ReferentialAction,
+    SqlExpression,
+    SqlType,
+    TypeKind,
+)
+from pyoq.schema.mysql.types import mysql_enum_values, mysql_type
+
+_KEY_KINDS = {"PRIMARY KEY": KeyKind.PRIMARY, "UNIQUE": KeyKind.UNIQUE}
+_FOREIGN_KEY = "FOREIGN KEY"
+_REFERENTIAL_ACTIONS = {
+    "NO ACTION": ReferentialAction.NO_ACTION,
+    "RESTRICT": ReferentialAction.RESTRICT,
+    "CASCADE": ReferentialAction.CASCADE,
+    "SET NULL": ReferentialAction.SET_NULL,
+    "SET DEFAULT": ReferentialAction.SET_DEFAULT,
+}
+_BASE_TABLE = "BASE TABLE"
+_VIEW_COMMENT = "VIEW"
+_AUTO_INCREMENT = "AUTO_INCREMENT"
+_GENERATED = "GENERATED"
+_STORED = "STORED"
+_EXPRESSION_DEFAULT = "DEFAULT_GENERATED"
+_DESCENDING_COLLATION = "D"
+_UNQUOTED_DEFAULT_KINDS = frozenset(
+    {
+        TypeKind.BOOLEAN,
+        TypeKind.SMALL_INTEGER,
+        TypeKind.INTEGER,
+        TypeKind.BIG_INTEGER,
+        TypeKind.DECIMAL,
+        TypeKind.REAL,
+        TypeKind.DOUBLE,
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ObjectRecord:
+    name: str
+    table_type: str
+    comment_text: str
+    definition_text: str | None
+
+    @property
+    def is_table(self) -> bool:
+        return self.table_type == _BASE_TABLE
+
+    @property
+    def comment(self) -> str | None:
+        if not self.is_table or self.comment_text == "":
+            return None
+        return self.comment_text
+
+    @property
+    def definition(self) -> SqlExpression | None:
+        text = "" if self.definition_text is None else self.definition_text.strip()
+        return None if text == "" else SqlExpression(text)
+
+
+@dataclass(frozen=True, slots=True)
+class ColumnRecord:
+    table: str
+    name: str
+    column_type: str
+    nullable_text: str
+    default_text: str | None
+    extra: str
+    generation_expression: str
+    comment_text: str
+
+    @property
+    def enum_values(self) -> tuple[str, ...]:
+        """The labels this column's enum lists, or none if it is not one."""
+        return mysql_enum_values(self.column_type)
+
+    @property
+    def enum_name(self) -> Identifier:
+        """What to call an enum MySQL keeps on a column rather than by name.
+
+        MySQL has no enum type of its own, so the column it belongs to is the
+        only thing that identifies it.
+        """
+        return Identifier(f"{self.table}_{self.name}")
+
+    @property
+    def data_type(self) -> SqlType:
+        values = self.enum_values
+        if not values:
+            return mysql_type(self.column_type)
+        return SqlType(
+            TypeKind.ENUM,
+            self.column_type,
+            named_type=ObjectReference(self.enum_name),
+        )
+
+    @property
+    def nullable(self) -> bool:
+        return self.nullable_text.upper() == "YES"
+
+    @property
+    def comment(self) -> str | None:
+        return None if self.comment_text == "" else self.comment_text
+
+    @property
+    def generated(self) -> GeneratedValue | None:
+        markers = frozenset(self.extra.upper().split())
+        if _AUTO_INCREMENT in markers:
+            return GeneratedValue(GeneratedKind.IDENTITY_BY_DEFAULT)
+        if _GENERATED not in markers:
+            return None
+        kind = (
+            GeneratedKind.COMPUTED_STORED
+            if _STORED in markers
+            else GeneratedKind.COMPUTED_VIRTUAL
+        )
+        return GeneratedValue(kind, SqlExpression(self.generation_expression))
+
+    @property
+    def default(self) -> SqlExpression | None:
+        if self.default_text is None or self.generated is not None:
+            return None
+        if _EXPRESSION_DEFAULT in frozenset(self.extra.upper().split()):
+            return SqlExpression(self.default_text)
+        if self.data_type.kind in _UNQUOTED_DEFAULT_KINDS:
+            return SqlExpression(self.default_text)
+        return SqlExpression(_quoted(self.default_text))
+
+
+@dataclass(frozen=True, slots=True)
+class ConstraintRecord:
+    table: str
+    name: str
+    constraint_type: str
+    column: str
+    target_schema: str | None
+    target_table: str | None
+    target_column: str | None
+    on_update: str | None
+    on_delete: str | None
+
+    @property
+    def key_kind(self) -> KeyKind | None:
+        return _KEY_KINDS.get(self.constraint_type)
+
+    @property
+    def is_foreign_key(self) -> bool:
+        return self.constraint_type == _FOREIGN_KEY
+
+    @property
+    def target_reference(self) -> ObjectReference | None:
+        if self.target_schema is None or self.target_table is None:
+            return None
+        return ObjectReference(
+            Identifier(self.target_table),
+            Identifier(self.target_schema),
+        )
+
+    @property
+    def target_identifier(self) -> Identifier:
+        if self.target_column is None:
+            message = f"MySQL foreign key {self.name!r} has no referenced column"
+            raise SchemaInspectionError(message)
+        return Identifier(self.target_column)
+
+    @property
+    def update_action(self) -> ReferentialAction:
+        return _referential_action(self.on_update)
+
+    @property
+    def delete_action(self) -> ReferentialAction:
+        return _referential_action(self.on_delete)
+
+
+@dataclass(frozen=True, slots=True)
+class CheckRecord:
+    table: str
+    name: str
+    clause: str
+
+
+@dataclass(frozen=True, slots=True)
+class IndexRecord:
+    table: str
+    name: str
+    non_unique: int
+    column: str | None
+    collation: str | None
+    expression: str | None
+    index_type: str
+
+    @property
+    def unique(self) -> bool:
+        return self.non_unique == 0
+
+    @property
+    def method(self) -> str:
+        return self.index_type.lower()
+
+    @property
+    def term(self) -> IndexTerm:
+        descending = self.collation == _DESCENDING_COLLATION
+        if self.column is not None:
+            return IndexTerm(Identifier(self.column), None, descending)
+        if self.expression is None:
+            message = f"MySQL index {self.name!r} has an unreadable term"
+            raise SchemaInspectionError(message)
+        return IndexTerm(None, SqlExpression(self.expression), descending)
+
+
+def read_object(row: tuple[object, ...]) -> ObjectRecord:
+    values = _row(row, 4)
+    return ObjectRecord(
+        _text(values[0]),
+        _text(values[1]),
+        _text(values[2]),
+        _optional_text(values[3]),
+    )
+
+
+def read_column(row: tuple[object, ...]) -> ColumnRecord:
+    values = _row(row, 8)
+    return ColumnRecord(
+        _text(values[0]),
+        _text(values[1]),
+        _text(values[2]),
+        _text(values[3]),
+        _optional_text(values[4]),
+        _text(values[5]),
+        _text(values[6]),
+        _text(values[7]),
+    )
+
+
+def read_constraint(row: tuple[object, ...]) -> ConstraintRecord:
+    values = _row(row, 9)
+    return ConstraintRecord(
+        _text(values[0]),
+        _text(values[1]),
+        _text(values[2]),
+        _text(values[3]),
+        _optional_text(values[4]),
+        _optional_text(values[5]),
+        _optional_text(values[6]),
+        _optional_text(values[7]),
+        _optional_text(values[8]),
+    )
+
+
+def read_check(row: tuple[object, ...]) -> CheckRecord:
+    values = _row(row, 3)
+    return CheckRecord(_text(values[0]), _text(values[1]), _text(values[2]))
+
+
+def read_index(row: tuple[object, ...]) -> IndexRecord:
+    values = _row(row, 7)
+    return IndexRecord(
+        _text(values[0]),
+        _text(values[1]),
+        _number(values[2]),
+        _optional_text(values[3]),
+        _optional_text(values[4]),
+        _optional_text(values[5]),
+        _text(values[6]),
+    )
+
+
+def _referential_action(rule: str | None) -> ReferentialAction:
+    action = None if rule is None else _REFERENTIAL_ACTIONS.get(rule.upper())
+    if action is None:
+        message = f"unsupported MySQL referential action: {rule!r}"
+        raise SchemaInspectionError(message)
+    return action
+
+
+def _quoted(value: str) -> str:
+    escaped = value.replace("'", "''")
+    return f"'{escaped}'"
+
+
+def _row(row: tuple[object, ...], width: int) -> tuple[object, ...]:
+    if len(row) != width:
+        message = "MySQL catalog row has an unexpected shape"
+        raise SchemaInspectionError(message)
+    return row
+
+
+def _text(value: object) -> str:
+    if not isinstance(value, str):
+        message = f"MySQL catalog value is not text: {value!r}"
+        raise SchemaInspectionError(message)
+    return value
+
+
+def _optional_text(value: object) -> str | None:
+    return None if value is None else _text(value)
+
+
+def _number(value: object) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        message = f"MySQL catalog value is not a number: {value!r}"
+        raise SchemaInspectionError(message)
+    return value
+
+
+__all__ = (
+    "CheckRecord",
+    "ColumnRecord",
+    "ConstraintRecord",
+    "IndexRecord",
+    "ObjectRecord",
+    "read_check",
+    "read_column",
+    "read_constraint",
+    "read_index",
+    "read_object",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RoutineRecord:
+    name: str
+    kind: str
+    returns: str | None
+    position: int | None
+    parameter_name: str | None
+    mode: str | None
+    parameter_type: str | None
+
+
+def read_routine(row: tuple[object, ...]) -> RoutineRecord:
+    values = _row(row, 7)
+    return RoutineRecord(
+        _text(values[0]),
+        _text(values[1]),
+        _optional_text(values[2]),
+        None if values[3] is None else _number(values[3]),
+        _optional_text(values[4]),
+        _optional_text(values[5]),
+        _optional_text(values[6]),
+    )