sqlrules-mysql 1.0.0__py3-none-any.whl

sqlrules_mysql/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from sqlrules.plugins import PLUGIN_API_VERSION
+from sqlrules.translators import TranslatorRegistry
+from sqlrules_mysql.fulltext import translate_fulltext_match
+from sqlrules_mysql.json import translate_json_contains, translate_json_has_key
+from sqlrules_mysql.pattern import translate_pattern
+from sqlrules_mysql.type_check import translate_type_check
+
+__version__ = "1.0.0"
+
+
+class MysqlPlugin:
+    """Register MySQL / MariaDB constraint translators."""
+
+    name = "mysql"
+    api_version = PLUGIN_API_VERSION
+
+    def register(self, registry: TranslatorRegistry) -> None:
+        registry.register_constraint(
+            "pattern",
+            translate_pattern,
+            on_conflict="replace",
+        )
+        registry.register_constraint(
+            "type_check",
+            translate_type_check,
+            on_conflict="replace",
+        )
+        for operator, translator in (
+            ("json_contains", translate_json_contains),
+            ("json_has_key", translate_json_has_key),
+            ("fulltext_match", translate_fulltext_match),
+        ):
+            registry.register_constraint(operator, translator, on_conflict="replace")
+
+
+__all__ = [
+    "MysqlPlugin",
+    "__version__",
+    "translate_fulltext_match",
+    "translate_json_contains",
+    "translate_json_has_key",
+    "translate_pattern",
+    "translate_type_check",
+]

sqlrules_mysql/fulltext.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def translate_fulltext_match(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``fulltext_match`` to MySQL ``MATCH (...) AGAINST (...)``.
+
+    Applications remain responsible for having a FULLTEXT index on the
+    target column(s).
+    """
+    return cast(ColumnElement[bool], column.match(constraint.value))

sqlrules_mysql/json.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+from typing import Any, cast
+
+from sqlalchemy import func, literal
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def _json_path_for_key(key: Any) -> str:
+    """Build a JSONPath for a single object key (never a full-path escape hatch)."""
+    text = str(key)
+    escaped = text.replace("\\", "\\\\").replace('"', '\\"')
+    return f'$."{escaped}"'
+
+
+def translate_json_contains(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``json_contains`` to MySQL ``JSON_CONTAINS``."""
+    payload = constraint.value
+    if not isinstance(payload, str):
+        payload = json.dumps(payload, separators=(",", ":"))
+    return cast(ColumnElement[bool], func.json_contains(column, payload) == 1)
+
+
+def translate_json_has_key(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``json_has_key`` to MySQL ``JSON_CONTAINS_PATH``."""
+    path = _json_path_for_key(constraint.value)
+    return cast(
+        ColumnElement[bool],
+        func.json_contains_path(column, literal("one"), path) == 1,
+    )

sqlrules_mysql/pattern.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.constraints import pattern_text
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def translate_pattern(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``pattern`` to MySQL/MariaDB ``REGEXP``.
+
+    MySQL ``REGEXP`` is case-insensitive for non-binary collations. SQLRules
+    follows that dialect behavior rather than inventing ``REGEXP BINARY``.
+    """
+    pattern, _ignore_case = pattern_text(constraint.value)
+    return cast(ColumnElement[bool], column.op("REGEXP")(pattern))

sqlrules_mysql/type_check.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+from datetime import date, datetime, time
+from decimal import Decimal
+from typing import Any, cast
+from uuid import UUID
+
+from sqlalchemy import Boolean, Date, DateTime, Float, Integer, Numeric, String, Time
+from sqlalchemy.sql.elements import ColumnElement
+from sqlalchemy.sql.sqltypes import NullType
+from sqlalchemy.types import TypeEngine
+
+from sqlrules.constraints import type_spec
+from sqlrules.errors import UnsupportedConstraintError
+from sqlrules.ir import CompilationContext, Constraint, TypeSpec
+
+_INT_TEXT = r"^[+-]?(0|[1-9][0-9]*)$"
+_FLOAT_TEXT = r"^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?$"
+_DATE_TEXT = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$"
+_DATETIME_TEXT = (
+    r"^[0-9]{4}-[0-9]{2}-[0-9]{2}[ T][0-9]{2}:[0-9]{2}:[0-9]{2}"
+    r"(\.[0-9]+)?([+-][0-9]{2}:?[0-9]{2}|Z)?$"
+)
+_TIME_TEXT = r"^[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?$"
+_UUID_TEXT = (
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+    r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+)
+
+
+def _is_type(column: ColumnElement[Any], *bases: type[TypeEngine[Any]]) -> bool:
+    col_type = column.type
+    if isinstance(col_type, NullType):
+        return False
+    return isinstance(col_type, bases)
+
+
+def _regexp(column: ColumnElement[Any], pattern: str) -> ColumnElement[bool]:
+    return cast(ColumnElement[bool], column.op("REGEXP")(pattern))
+
+
+def _wrap_none(
+    column: ColumnElement[Any],
+    predicate: ColumnElement[bool],
+    *,
+    allow_none: bool,
+) -> ColumnElement[bool]:
+    if allow_none:
+        return cast(ColumnElement[bool], column.is_(None) | predicate)
+    return predicate
+
+
+def _unsupported(field: str, spec: TypeSpec, suggestion: str) -> None:
+    raise UnsupportedConstraintError(
+        field=field,
+        operator="type_check",
+        value=spec,
+        suggestion=suggestion,
+    )
+
+
+def _predicate_int(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+) -> ColumnElement[bool]:
+    if _is_type(column, Integer):
+        return cast(ColumnElement[bool], column.isnot(None))
+    if spec.strict:
+        _unsupported(
+            field,
+            spec,
+            "MySQL strict int type_check requires an Integer column.",
+        )
+    if _is_type(column, String):
+        return _regexp(column, _INT_TEXT)
+    if _is_type(column, Float, Numeric):
+        return cast(ColumnElement[bool], column == column.cast(Integer).cast(Float))
+    _unsupported(
+        field,
+        spec,
+        "MySQL lax int type_check supports Integer, String, Float, or Numeric columns.",
+    )
+    raise AssertionError("unreachable")
+
+
+def _predicate_bool(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+) -> ColumnElement[bool]:
+    if spec.strict:
+        if _is_type(column, Boolean, Integer):
+            return cast(ColumnElement[bool], column.in_((True, False, 0, 1)))
+        _unsupported(
+            field,
+            spec,
+            "MySQL strict bool type_check requires a Boolean/Integer column.",
+        )
+    _unsupported(
+        field,
+        spec,
+        "MySQL lax bool type_check is not supported. Use strict=True.",
+    )
+    raise AssertionError("unreachable")
+
+
+def _predicate_str(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+) -> ColumnElement[bool]:
+    if _is_type(column, String):
+        return cast(ColumnElement[bool], column.isnot(None))
+    _unsupported(
+        field,
+        spec,
+        "MySQL str type_check requires a String/Text column.",
+    )
+    raise AssertionError("unreachable")
+
+
+def _predicate_float(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+) -> ColumnElement[bool]:
+    if _is_type(column, Float, Numeric, Integer):
+        return cast(ColumnElement[bool], column.isnot(None))
+    if spec.strict:
+        _unsupported(
+            field,
+            spec,
+            "MySQL strict float/Decimal type_check requires a numeric column.",
+        )
+    if _is_type(column, String):
+        return _regexp(column, _FLOAT_TEXT)
+    _unsupported(
+        field,
+        spec,
+        "MySQL float/Decimal type_check supports numeric or String columns.",
+    )
+    raise AssertionError("unreachable")
+
+
+def _predicate_temporal(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+    *,
+    sa_types: tuple[type[TypeEngine[Any]], ...],
+    text_pattern: str,
+) -> ColumnElement[bool]:
+    if _is_type(column, *sa_types):
+        return cast(ColumnElement[bool], column.isnot(None))
+    if spec.strict:
+        type_name = spec.python_type.__name__
+        _unsupported(
+            field,
+            spec,
+            f"MySQL strict {type_name} type_check requires a typed {type_name} column.",
+        )
+    if _is_type(column, String):
+        return _regexp(column, text_pattern)
+    type_name = spec.python_type.__name__
+    _unsupported(
+        field,
+        spec,
+        f"MySQL {type_name} type_check supports typed {type_name} or String columns.",
+    )
+    raise AssertionError("unreachable")
+
+
+def _predicate_uuid(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+) -> ColumnElement[bool]:
+    if "uuid" in type(column.type).__name__.lower():
+        return cast(ColumnElement[bool], column.isnot(None))
+    if spec.strict:
+        _unsupported(
+            field,
+            spec,
+            "MySQL strict UUID type_check requires a UUID column.",
+        )
+    if _is_type(column, String):
+        return _regexp(column, _UUID_TEXT)
+    _unsupported(
+        field,
+        spec,
+        "MySQL UUID type_check supports UUID or String columns.",
+    )
+    raise AssertionError("unreachable")
+
+
+def _build_predicate(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+) -> ColumnElement[bool]:
+    python_type = spec.python_type
+    if python_type is int:
+        return _predicate_int(column, spec, field)
+    if python_type is bool:
+        return _predicate_bool(column, spec, field)
+    if python_type is str:
+        return _predicate_str(column, spec, field)
+    if python_type in {float, Decimal}:
+        return _predicate_float(column, spec, field)
+    if python_type is date:
+        return _predicate_temporal(column, spec, field, sa_types=(Date,), text_pattern=_DATE_TEXT)
+    if python_type is datetime:
+        return _predicate_temporal(
+            column, spec, field, sa_types=(DateTime,), text_pattern=_DATETIME_TEXT
+        )
+    if python_type is time:
+        return _predicate_temporal(column, spec, field, sa_types=(Time,), text_pattern=_TIME_TEXT)
+    if python_type is UUID:
+        return _predicate_uuid(column, spec, field)
+    _unsupported(
+        field,
+        spec,
+        f"MySQL type_check has no translator for {python_type!r}.",
+    )
+    raise AssertionError("unreachable")
+
+
+def translate_type_check(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``type_check`` into MySQL shape/type predicates."""
+    del context
+    spec = type_spec(constraint.value)
+    predicate = _build_predicate(column, spec, constraint.field)
+    return _wrap_none(column, predicate, allow_none=spec.allow_none)

sqlrules_mysql-1.0.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: sqlrules-mysql
+Version: 1.0.0
+Summary: MySQL/MariaDB dialect plugin for SQLRules (REGEXP, JSON, full-text).
+Project-URL: Homepage, https://github.com/eddiethedean/sqlrules
+Project-URL: Repository, https://github.com/eddiethedean/sqlrules
+Project-URL: Issues, https://github.com/eddiethedean/sqlrules/issues
+Author: SQLRules Contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: mariadb,mysql,pydantic,sqlalchemy,sqlrules
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: sqlalchemy<3,>=2.0
+Requires-Dist: sqlrules<2,>=1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sqlrules-mysql
+
+MySQL / MariaDB dialect plugin for [SQLRules](https://github.com/eddiethedean/sqlrules).
+
+## Install
+
+```bash
+pip install sqlrules-mysql
+```
+
+## Usage
+
+```python
+from typing import Annotated, Any
+
+from pydantic import BaseModel, Field
+
+from sqlrules import Compiler, FullTextMatch, JsonContains
+from sqlrules_mysql import MysqlPlugin
+
+class RowFilter(BaseModel):
+    name: Annotated[str, Field(pattern=r"^A")]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+    body: Annotated[str, FullTextMatch("sqlrules")]
+
+compiler = Compiler(plugins=[MysqlPlugin()], dialect="mysql")
+```
+
+## Operators
+
+| IR operator | Notes |
+|---|---|
+| `pattern` | `REGEXP` (case-insensitive under typical collations) |
+| `type_check` | Shape/type predicates from `TypeSpec` (partial matrix) |
+| `json_contains` | `JSON_CONTAINS(column, payload) = 1` |
+| `json_has_key` | `JSON_CONTAINS_PATH(column, 'one', '$.key') = 1` |
+| `fulltext_match` | `MATCH(column) AGAINST (value)` — requires a FULLTEXT index |
+
+## Security note
+
+`pattern` / `fulltext_match` values are bound parameters, but evaluation cost
+is engine-dependent. Prefer static/allowlisted patterns and queries from
+untrusted input. See
+[SECURITY](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

sqlrules_mysql-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+sqlrules_mysql/__init__.py,sha256=wp61i0b9xeRI4TDnvhUmrnE5a9ItoFOG3syE5pmz5e8,1395
+sqlrules_mysql/fulltext.py,sha256=fTQWIvoYjbyDr9JeyIkUw_9wJbaJoG97mwEjjZ00euM,570
+sqlrules_mysql/json.py,sha256=QZAJRfs2hE8_Q7-DBIF54j9xnQ4Qn7LKz3Uvpi-bZJs,1269
+sqlrules_mysql/pattern.py,sha256=UspYJFHb7LbGtSAOwMHrF2P1iCImQxj4cKENOtCU_nQ,707
+sqlrules_mysql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlrules_mysql/type_check.py,sha256=kHS1jwr_xS0nhG7hui8DGYR0JfgZsTHVzt7bTWYMOak,7153
+sqlrules_mysql-1.0.0.dist-info/METADATA,sha256=HGfxqQJJBs0JS_h7oXBdZCoSiJYNqBnpFlrz71qJBWQ,2120
+sqlrules_mysql-1.0.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sqlrules_mysql-1.0.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
+sqlrules_mysql-1.0.0.dist-info/RECORD,,

sqlrules_mysql-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlrules_mysql-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SQLRules Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.