sqlrules-mysql 1.0.0__tar.gz → 2.0.0__tar.gz

{sqlrules_mysql-1.0.0 → sqlrules_mysql-2.0.0}/.gitignore

@@ -11,6 +11,7 @@ __pycache__/
 htmlcov/
 dist/
 dist-plugins/
+dist-missing/
 build/
 *.egg-info/
 .DS_Store

sqlrules_mysql-2.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.5
+Name: sqlrules-mysql
+Version: 2.0.0
+Summary: MySQL 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: 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<3,>=2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sqlrules-mysql
+
+MySQL backend provider for [SQLRules](https://github.com/eddiethedean/sqlrules).
+The package version follows the core 2.x line.
+
+This provider targets MySQL 8.0+. MariaDB is outside the supported server
+matrix because its regular-expression function API differs from MySQL's.
+
+## Install
+
+```bash
+pip install "sqlrules>=2,<3" "sqlrules-mysql>=2,<3"
+```
+
+## Use
+
+```python
+from typing import Annotated, Any
+
+from pydantic import Field
+from sqlalchemy import Column, JSON, MetaData, String, Table
+
+from sqlrules import Compiler, FullTextMatch, JsonContains, RuleSchema, where
+from sqlrules_mysql import MysqlPlugin
+
+rows = Table(
+    "rows",
+    MetaData(),
+    Column("name", String),
+    Column("meta", JSON),
+    Column("body", String),
+)
+
+
+class RowRules(RuleSchema):
+    name: Annotated[str, Field(pattern=r"^A")]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+    body: Annotated[str, FullTextMatch("sqlrules")]
+
+
+provider = MysqlPlugin(server_version=(8, 0, 36))
+compiled = Compiler(plugins=[provider]).compile(RowRules, rows)
+statement = rows.select().where(*where(compiled))
+```
+
+## Capabilities
+
+- `pattern`: MySQL `REGEXP`
+- JSON containment and key lookup
+- Full-text matching (requires a matching FULLTEXT index)
+- Safe lax text-to-int conversion on MySQL 8.0+
+
+Text-to-float and text-to-Decimal are compile-time capability errors. String
+Literal and Enum fields need an explicit binary or case-sensitive collation.
+See the [type support matrix](https://sqlrules.readthedocs.io/en/latest/TYPE_SUPPORT.html).
+
+## Pattern cost
+
+Untrusted regular expressions and full-text queries can be expensive. Prefer
+static or allowlisted values. See the SQLRules
+[security notes](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

sqlrules_mysql-2.0.0/README.md

@@ -0,0 +1,61 @@
+# sqlrules-mysql
+
+MySQL backend provider for [SQLRules](https://github.com/eddiethedean/sqlrules).
+The package version follows the core 2.x line.
+
+This provider targets MySQL 8.0+. MariaDB is outside the supported server
+matrix because its regular-expression function API differs from MySQL's.
+
+## Install
+
+```bash
+pip install "sqlrules>=2,<3" "sqlrules-mysql>=2,<3"
+```
+
+## Use
+
+```python
+from typing import Annotated, Any
+
+from pydantic import Field
+from sqlalchemy import Column, JSON, MetaData, String, Table
+
+from sqlrules import Compiler, FullTextMatch, JsonContains, RuleSchema, where
+from sqlrules_mysql import MysqlPlugin
+
+rows = Table(
+    "rows",
+    MetaData(),
+    Column("name", String),
+    Column("meta", JSON),
+    Column("body", String),
+)
+
+
+class RowRules(RuleSchema):
+    name: Annotated[str, Field(pattern=r"^A")]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+    body: Annotated[str, FullTextMatch("sqlrules")]
+
+
+provider = MysqlPlugin(server_version=(8, 0, 36))
+compiled = Compiler(plugins=[provider]).compile(RowRules, rows)
+statement = rows.select().where(*where(compiled))
+```
+
+## Capabilities
+
+- `pattern`: MySQL `REGEXP`
+- JSON containment and key lookup
+- Full-text matching (requires a matching FULLTEXT index)
+- Safe lax text-to-int conversion on MySQL 8.0+
+
+Text-to-float and text-to-Decimal are compile-time capability errors. String
+Literal and Enum fields need an explicit binary or case-sensitive collation.
+See the [type support matrix](https://sqlrules.readthedocs.io/en/latest/TYPE_SUPPORT.html).
+
+## Pattern cost
+
+Untrusted regular expressions and full-text queries can be expensive. Prefer
+static or allowlisted values. See the SQLRules
+[security notes](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

{sqlrules_mysql-1.0.0 → sqlrules_mysql-2.0.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlrules-mysql"
-version = "1.0.0"
-description = "MySQL/MariaDB dialect plugin for SQLRules (REGEXP, JSON, full-text)."
+version = "2.0.0"
+description = "MySQL dialect plugin for SQLRules (REGEXP, JSON, full-text)."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 authors = [{ name = "SQLRules Contributors" }]
-keywords = ["sqlrules", "mysql", "mariadb", "pydantic", "sqlalchemy"]
+keywords = ["sqlrules", "mysql", "pydantic", "sqlalchemy"]
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "License :: OSI Approved :: MIT License",
@@ -18,7 +18,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "sqlrules>=1,<2",
+  "sqlrules>=2,<3",
   "sqlalchemy>=2.0,<3",
 ]
 

sqlrules_mysql-2.0.0/src/sqlrules_mysql/__init__.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from sqlrules.backend import prepare_scalar
+from sqlrules.ir import CompilationContext, PreparedValue, RuleField
+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.length import translate_max_length, translate_min_length
+from sqlrules_mysql.pattern import translate_pattern
+
+__version__ = "2.0.0"
+
+
+class MysqlPlugin:
+    """Register MySQL constraint translators."""
+
+    name = "mysql"
+    api_version = PLUGIN_API_VERSION
+
+    def __init__(self, *, server_version: tuple[int, ...] | None = None) -> None:
+        self.server_version = tuple(server_version) if server_version is not None else None
+
+    def capabilities(self) -> Mapping[str, Any]:
+        return {
+            "backend": self.name,
+            "server_version": self.server_version,
+            "native_scalar_types": (
+                "bool",
+                "int",
+                "float",
+                "decimal",
+                "str",
+                "date",
+                "datetime",
+                "time",
+            ),
+            "safe_text_numeric_conversion": self.server_version is not None
+            and self.server_version >= (8, 0),
+            "safe_text_numeric_targets": (
+                ("int",)
+                if self.server_version is not None and self.server_version >= (8, 0)
+                else ()
+            ),
+            "assumptions": (
+                "MySQL 8.0 REGEXP and native column types provide the advertised type evidence.",
+                "Lax integer/float/Decimal conversions accept the documented lexical profile.",
+            ),
+        }
+
+    def prepare_value(
+        self,
+        column: Any,
+        field: RuleField,
+        context: CompilationContext,
+    ) -> PreparedValue:
+        return prepare_scalar(column, field, context, backend=self.name)
+
+    def register(self, registry: TranslatorRegistry) -> None:
+        registry.register_constraint(
+            "pattern",
+            translate_pattern,
+            on_conflict="replace",
+        )
+        for operator, translator in (
+            ("min_length", translate_min_length),
+            ("max_length", translate_max_length),
+            ("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_max_length",
+    "translate_min_length",
+    "translate_json_contains",
+    "translate_json_has_key",
+    "translate_pattern",
+]

{sqlrules_mysql-1.0.0 → sqlrules_mysql-2.0.0}/src/sqlrules_mysql/json.py

@@ -22,9 +22,7 @@ def translate_json_contains(
     context: CompilationContext,
 ) -> ColumnElement[bool]:
     """Translate ``json_contains`` to MySQL ``JSON_CONTAINS``."""
-    payload = constraint.value
-    if not isinstance(payload, str):
-        payload = json.dumps(payload, separators=(",", ":"))
+    payload = json.dumps(constraint.value, separators=(",", ":"))
     return cast(ColumnElement[bool], func.json_contains(column, payload) == 1)
 
 

sqlrules_mysql-2.0.0/src/sqlrules_mysql/length.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy import func
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def translate_min_length(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Compare MySQL character count, not encoded byte length."""
+    return cast(ColumnElement[bool], func.char_length(column) >= constraint.value)
+
+
+def translate_max_length(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Compare MySQL character count, not encoded byte length."""
+    return cast(ColumnElement[bool], func.char_length(column) <= constraint.value)
+
+
+__all__ = ["translate_max_length", "translate_min_length"]

sqlrules_mysql-2.0.0/src/sqlrules_mysql/pattern.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy import func
+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 ``REGEXP_LIKE``.
+
+    MySQL's default matching follows the expression collation. Use
+    ``REGEXP_LIKE``'s match type to keep SQLRules patterns case-sensitive by
+    default and preserve an explicit ``re.IGNORECASE`` flag.
+    """
+    pattern, ignore_case = pattern_text(constraint.value)
+    match_type = "i" if ignore_case else "c"
+    return cast(ColumnElement[bool], func.regexp_like(column, pattern, match_type))

sqlrules_mysql-2.0.0/tests/test_mysql_plugin.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from pydantic import Field
+from sqlalchemy import JSON, Column, MetaData, String, Table
+from sqlalchemy.dialects.mysql import dialect
+from sqlrules_mysql import MysqlPlugin, __version__
+
+from sqlrules import Compiler, FullTextMatch, JsonContains, RuleSchema
+from sqlrules.conformance import run_basic_conformance
+
+
+def test_version_and_plugin_conformance() -> None:
+    assert __version__ == "2.0.0"
+    run_basic_conformance(MysqlPlugin(), operator="pattern")
+
+
+def test_pattern_json_and_fulltext_constraints_compile() -> None:
+    class Rules(RuleSchema):
+        name: Annotated[str, Field(pattern=r"^A")]
+        meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+        body: Annotated[str, FullTextMatch("sqlrules")]
+
+    table = Table(
+        "rows",
+        MetaData(),
+        Column("name", String),
+        Column("meta", JSON),
+        Column("body", String),
+    )
+    compiled = Compiler(plugins=[MysqlPlugin(server_version=(8, 0, 36))]).compile(Rules, table)
+    statement = compiled.predicate.compile(dialect=dialect())
+    sql = str(statement).lower()
+    assert "regexp_like" in sql
+    assert "c" in statement.params.values()
+    assert "json_contains" in sql
+    assert "match" in sql
+
+
+def test_integer_text_profile_is_server_version_gated() -> None:
+    class Rules(RuleSchema):
+        count: int
+
+    table = Table("rows", MetaData(), Column("count", String))
+    from sqlrules import CapabilityError
+
+    try:
+        Compiler(plugins=[MysqlPlugin()]).compile(Rules, table)
+    except CapabilityError as exc:
+        assert "MySQL 8.0+" in str(exc)
+    else:  # pragma: no cover - assertion is the capability contract
+        raise AssertionError("text-to-integer needs a configured MySQL version")
+
+    compiled = Compiler(plugins=[MysqlPlugin(server_version=(8, 0, 36))]).compile(Rules, table)
+    assert compiled.fields[0].coercion == "text-to-int"

sqlrules_mysql-1.0.0/PKG-INFO

@@ -1,66 +0,0 @@
-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/README.md

@@ -1,44 +0,0 @@
-# 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/src/sqlrules_mysql/__init__.py

@@ -1,46 +0,0 @@
-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-1.0.0/src/sqlrules_mysql/pattern.py

@@ -1,22 +0,0 @@
-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-1.0.0/src/sqlrules_mysql/type_check.py

@@ -1,238 +0,0 @@
-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/tests/test_mysql_plugin.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-from typing import Annotated, Any
-
-from pydantic import BaseModel, Field
-from sqlalchemy import Column, MetaData, String, Table, Text
-from sqlalchemy.dialects import mysql
-from sqlrules_mysql import MysqlPlugin, __version__
-
-from sqlrules import Compiler, FullTextMatch, JsonContains, JsonHasKey
-from sqlrules.conformance import run_basic_conformance
-
-
-def test_version() -> None:
-    assert __version__ == "1.0.0"
-
-
-def test_conformance() -> None:
-    run_basic_conformance(MysqlPlugin(), operator="pattern")
-
-
-def test_pattern_and_json_compile() -> None:
-    class Filter(BaseModel):
-        name: Annotated[str, Field(pattern=r"^A")]
-        meta: Annotated[dict[str, Any], JsonContains({"active": True}), JsonHasKey("active")]
-        body: Annotated[str, FullTextMatch("hello")]
-
-    table = Table(
-        "items",
-        MetaData(),
-        Column("name", String),
-        Column("meta", Text),
-        Column("body", Text),
-    )
-    rules = Compiler(
-        plugins=[MysqlPlugin()],
-        dialect="mysql",
-        cache=False,
-    ).compile(Filter, table)
-    dialect = mysql.dialect()
-    assert "REGEXP" in str(rules["name"][0].compile(dialect=dialect))
-
-    contains_sql = str(rules["meta"][0].compile(dialect=dialect)).lower()
-    has_key_sql = str(rules["meta"][1].compile(dialect=dialect)).lower()
-    assert "json_contains(" in contains_sql
-    assert "json_contains_path" not in contains_sql
-    assert "json_contains_path" in has_key_sql
-
-    body_sql = str(rules["body"][0].compile(dialect=dialect)).lower()
-    assert "match" in body_sql and "against" in body_sql
-
-
-def test_type_check_int_and_lax_string() -> None:
-    from sqlalchemy import Integer
-
-    class Typed(BaseModel):
-        age: int
-
-    class Textual(BaseModel):
-        age: int
-
-    typed_table = Table("users", MetaData(), Column("age", Integer))
-    text_table = Table("rows", MetaData(), Column("age", String))
-    compiler = Compiler(
-        plugins=[MysqlPlugin()],
-        dialect="mysql",
-        emit_type_checks=True,
-        cache=False,
-    )
-    typed_sql = str(compiler.compile(Typed, typed_table)["age"][0].compile(dialect=mysql.dialect()))
-    text_sql = str(compiler.compile(Textual, text_table)["age"][0].compile(dialect=mysql.dialect()))
-    assert "IS NOT NULL" in typed_sql.upper()
-    assert "REGEXP" in text_sql