sqlrules-sqlite 1.0.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

sqlrules_sqlite/__init__.py

@@ -1,35 +1,75 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
+from typing import Any
+
+from sqlrules.backend import prepare_sqlite_scalar
+from sqlrules.ir import CompilationContext, PreparedValue, RuleField
 from sqlrules.plugins import PLUGIN_API_VERSION
 from sqlrules.translators import TranslatorRegistry
 from sqlrules_sqlite.json import translate_json_contains, translate_json_has_key
+from sqlrules_sqlite.length import translate_max_length, translate_min_length
 from sqlrules_sqlite.pattern import translate_pattern
 from sqlrules_sqlite.regexp import register_regexp
-from sqlrules_sqlite.type_check import translate_type_check
+from sqlrules_sqlite.runtime import register_sqlite_functions
 
-__version__ = "1.0.1"
+__version__ = "2.0.0"
 
 
 class SQLitePlugin:
     """Register SQLite-specific constraint translators.
 
-    The ``pattern`` and text-shaped ``type_check`` translators emit
-    ``column REGEXP pattern``. Call :func:`register_regexp` on each SQLite
-    connection before executing the resulting SQL.
+    Pattern and text-coercion expressions emit ``column REGEXP pattern``;
+    length constraints use SQLRules' Unicode-aware character counter. Call
+    :func:`register_sqlite_functions` on each SQLite connection before
+    executing SQL that needs these functions. ``register_regexp`` remains as a
+    backward-compatible alias.
     """
 
     name = "sqlite"
     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", "str"),
+            "safe_text_numeric_conversion": True,
+            "safe_text_numeric_targets": ("int", "float"),
+            "assumptions": (
+                "Runtime typeof() storage classes determine bool/int/float/text values.",
+                "Register SQLRules SQLite functions on each connection when using text "
+                "coercion, patterns, or string length constraints.",
+                "Date/time/UUID and exact Decimal checks require "
+                "a future explicit storage adapter.",
+            ),
+        }
+
+    def prepare_value(
+        self,
+        column: Any,
+        field: RuleField,
+        context: CompilationContext,
+    ) -> PreparedValue:
+        return prepare_sqlite_scalar(column, field, context)
+
     def register(self, registry: TranslatorRegistry) -> None:
         registry.register_constraint(
-            "pattern",
-            translate_pattern,
+            "min_length",
+            translate_min_length,
             on_conflict="replace",
         )
         registry.register_constraint(
-            "type_check",
-            translate_type_check,
+            "max_length",
+            translate_max_length,
+            on_conflict="replace",
+        )
+        registry.register_constraint(
+            "pattern",
+            translate_pattern,
             on_conflict="replace",
         )
         registry.register_constraint(
@@ -48,8 +88,8 @@ __all__ = [
     "SQLitePlugin",
     "__version__",
     "register_regexp",
+    "register_sqlite_functions",
     "translate_json_contains",
     "translate_json_has_key",
     "translate_pattern",
-    "translate_type_check",
 ]

sqlrules_sqlite/json.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from typing import Any, cast
 
-from sqlalchemy import String, func, literal, type_coerce
+from sqlalchemy import String, and_, case, func, literal, select, type_coerce
 from sqlalchemy.sql.elements import ColumnElement
 
 from sqlrules.ir import CompilationContext, Constraint
@@ -20,27 +20,70 @@ def _compact_dumps(value: Any) -> str:
     return json.dumps(value, separators=(",", ":"))
 
 
-def _extract_equals(
-    column: ColumnElement[Any],
+def _safe_json(column: ColumnElement[Any]) -> ColumnElement[Any]:
+    """Replace malformed documents before any JSON1 function can inspect them."""
+    return case(
+        (func.json_valid(column), type_coerce(column, String)),
+        else_=literal("{}"),
+    )
+
+
+def _json_child_count(
+    document: ColumnElement[Any],
+    path: str,
+) -> ColumnElement[Any]:
+    children = func.json_each(document, path).table_valued("key").alias()
+    return select(func.count()).select_from(children).scalar_subquery()
+
+
+def _join_json_path(parent: str, child: str) -> str:
+    return f"{parent}{child[1:]}"
+
+
+def _json_value_equals(
+    document: ColumnElement[Any],
     path: str,
     expected: Any,
 ) -> ColumnElement[bool]:
-    """Compare ``json_extract`` to ``expected`` using SQLite JSON1 affinities."""
-    extracted = func.json_extract(column, path)
+    """Compare JSON values structurally, independent of object key order."""
+    json_type = func.json_type(document, path)
+    extracted = func.json_extract(document, path)
     if expected is None:
-        return cast(ColumnElement[bool], func.json_type(column, path) == "null")
+        return cast(ColumnElement[bool], json_type == "null")
     if isinstance(expected, bool):
-        return cast(ColumnElement[bool], extracted == (1 if expected else 0))
-    if isinstance(expected, (dict, list)):
-        compact = _compact_dumps(expected)
+        expected_type = "true" if expected else "false"
+        return cast(ColumnElement[bool], json_type == expected_type)
+    if isinstance(expected, dict):
+        parts: list[ColumnElement[bool]] = [
+            cast(ColumnElement[bool], json_type == "object"),
+            cast(ColumnElement[bool], _json_child_count(document, path) == len(expected)),
+        ]
+        parts.extend(
+            _json_value_equals(
+                document,
+                _join_json_path(path, _json_path_for_key(key)),
+                child,
+            )
+            for key, child in expected.items()
+        )
+        return cast(ColumnElement[bool], and_(*parts))
+    if isinstance(expected, list):
+        parts = [
+            cast(ColumnElement[bool], json_type == "array"),
+            cast(ColumnElement[bool], _json_child_count(document, path) == len(expected)),
+        ]
+        parts.extend(
+            _json_value_equals(document, f"{path}[{index}]", child)
+            for index, child in enumerate(expected)
+        )
+        return cast(ColumnElement[bool], and_(*parts))
+    if isinstance(expected, (int, float)):
         return cast(
             ColumnElement[bool],
-            func.json(extracted) == func.json(literal(compact)),
+            json_type.in_(("integer", "real")) & (extracted == expected),
         )
-    if isinstance(expected, (int, float)):
-        return cast(ColumnElement[bool], extracted == expected)
     if isinstance(expected, str):
-        return cast(ColumnElement[bool], extracted == expected)
+        return cast(ColumnElement[bool], (json_type == "text") & (extracted == expected))
     compact = _compact_dumps(expected)
     return cast(
         ColumnElement[bool],
@@ -53,34 +96,28 @@ def translate_json_contains(
     column: ColumnElement[Any],
     context: CompilationContext,
 ) -> ColumnElement[bool]:
-    """Translate ``json_contains`` using SQLite JSON1 ``json_extract``.
-
-    For object payloads, checks that each top-level key extracts to the
-    expected JSON value. This is a deterministic subset of JSON containment
-    suitable for common filter models; nested deep-merge semantics are not
-    emulated.
-    """
+    """Translate the supported SQLite JSON containment subset safely."""
     value = constraint.value
+    safe_json = _safe_json(column)
+    valid_document = func.json_valid(column)
     if isinstance(value, dict):
         if not value:
-            # Align with PostgreSQL ``@> '{}'``: require a non-NULL JSON object.
             return cast(
                 ColumnElement[bool],
-                column.is_not(None) & (func.json_type(column) == "object"),
+                column.is_not(None) & valid_document & (func.json_type(safe_json) == "object"),
             )
-        parts: list[ColumnElement[bool]] = []
-        for key, expected in value.items():
-            parts.append(_extract_equals(column, _json_path_for_key(key), expected))
-        expression = parts[0]
-        for part in parts[1:]:
-            expression = expression & part
-        return cast(ColumnElement[bool], expression)
-
-    # Scalar / array payload: compare whole-document JSON text via json().
-    compact = _compact_dumps(value)
+        parts = [
+            _json_value_equals(safe_json, _json_path_for_key(key), expected)
+            for key, expected in value.items()
+        ]
+        return cast(
+            ColumnElement[bool],
+            valid_document & (func.json_type(safe_json) == "object") & and_(*parts),
+        )
+
     return cast(
         ColumnElement[bool],
-        func.json(type_coerce(column, String)) == func.json(literal(compact)),
+        valid_document & _json_value_equals(safe_json, "$", value),
     )
 
 
@@ -89,6 +126,9 @@ def translate_json_has_key(
     column: ColumnElement[Any],
     context: CompilationContext,
 ) -> ColumnElement[bool]:
-    """Translate ``json_has_key`` via ``json_type(column, path) IS NOT NULL``."""
+    """Translate ``json_has_key`` without evaluating JSON1 on malformed input."""
     path = _json_path_for_key(constraint.value)
-    return cast(ColumnElement[bool], func.json_type(column, path).is_not(None))
+    return cast(
+        ColumnElement[bool],
+        func.json_valid(column) & func.json_type(_safe_json(column), path).is_not(None),
+    )

sqlrules_sqlite/length.py

@@ -0,0 +1,35 @@
+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]:
+    """Use the registered Python-compatible code-point counter."""
+    return cast(
+        ColumnElement[bool],
+        func.sqlrules_char_length(column) >= constraint.value,
+    )
+
+
+def translate_max_length(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Use the registered Python-compatible code-point counter."""
+    return cast(
+        ColumnElement[bool],
+        func.sqlrules_char_length(column) <= constraint.value,
+    )
+
+
+__all__ = ["translate_max_length", "translate_min_length"]

sqlrules_sqlite/pattern.py

@@ -16,7 +16,8 @@ def translate_pattern(
     """Translate ``pattern`` to SQLite ``column REGEXP pattern``.
 
     Case-insensitive patterns are encoded with a ``(?i)`` prefix so
-    :func:`sqlrules_sqlite.register_regexp` can apply ``re.IGNORECASE``.
+    :func:`sqlrules_sqlite.register_sqlite_functions` can apply
+    ``re.IGNORECASE``.
     Callers must enable REGEXP on the SQLite connection before execution.
     """
     pattern, ignore_case = pattern_text(constraint.value)

sqlrules_sqlite/regexp.py

@@ -1,30 +1,13 @@
 from __future__ import annotations
 
-import re
 import sqlite3
 
+from sqlrules_sqlite.runtime import register_sqlite_functions
 
-def register_regexp(connection: sqlite3.Connection) -> None:
-    """Register a flag-aware ``REGEXP`` function on a SQLite connection.
-
-    The SQLRules SQLite ``pattern`` translator emits
-    ``column REGEXP pattern``. SQLite does not ship REGEXP by default;
-    call this once per connection before executing compiled SQL.
 
-    The helper interprets an optional ``(?i)`` prefix (inserted by the
-    pattern translator for case-insensitive ``PatternSpec`` values).
-
-    Invalid patterns raise ``re.error`` (surfaced by SQLite as an
-    operational error) instead of silently matching nothing.
-    """
+def register_regexp(connection: sqlite3.Connection) -> None:
+    """Backward-compatible alias for :func:`register_sqlite_functions`."""
+    register_sqlite_functions(connection)
 
-    def regexp(pattern: str | None, value: str | None) -> bool:
-        if pattern is None or value is None:
-            return False
-        flags = 0
-        if pattern.startswith("(?i)"):
-            flags |= re.IGNORECASE
-            pattern = pattern[4:]
-        return re.search(pattern, value, flags) is not None
 
-    connection.create_function("REGEXP", 2, regexp)
+__all__ = ["register_regexp"]

sqlrules_sqlite/runtime.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import re
+import sqlite3
+from typing import Any
+
+
+def _regexp(pattern: str | None, value: str | None) -> bool:
+    # SQLite may evaluate a REGEXP branch even when a neighboring typeof()
+    # predicate is false. Treat non-text source values as a non-match so
+    # mixed-storage tables cannot raise Python TypeError.
+    if not isinstance(pattern, str) or not isinstance(value, str):
+        return False
+    flags = 0
+    if pattern.startswith("(?i)"):
+        flags |= re.IGNORECASE
+        pattern = pattern[4:]
+    return re.search(pattern, value, flags) is not None
+
+
+def _char_length(value: Any) -> int | None:
+    """Use Python's Unicode code-point count, including text after U+0000."""
+    return len(value) if isinstance(value, str) else None
+
+
+def register_sqlite_functions(connection: sqlite3.Connection) -> None:
+    """Register SQLRules functions needed by SQLite rules on this connection.
+
+    SQLite does not provide REGEXP, and its built-in length(TEXT) stops at the
+    first U+0000. SQLRules uses these callbacks for regex/text coercion and
+    exact Python-compatible string length constraints.
+    """
+    connection.create_function("REGEXP", 2, _regexp)
+    connection.create_function("sqlrules_char_length", 1, _char_length)

sqlrules_sqlite-2.0.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: sqlrules-sqlite
+Version: 2.0.0
+Summary: SQLite dialect plugin for SQLRules (REGEXP, Unicode length, and JSON helpers).
+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: pydantic,sqlalchemy,sqlite,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-sqlite
+
+SQLite backend provider for [SQLRules](https://github.com/eddiethedean/sqlrules).
+The package version follows the core 2.x line.
+
+## Install
+
+```bash
+pip install "sqlrules>=2,<3" "sqlrules-sqlite>=2,<3"
+```
+
+## Use
+
+```python
+from typing import Annotated, Any
+
+from pydantic import Field
+from sqlalchemy import Column, JSON, MetaData, String, Table, create_engine, event
+
+from sqlrules import Compiler, JsonContains, RuleSchema, where
+from sqlrules_sqlite import SQLitePlugin, register_sqlite_functions
+
+rows = Table("rows", MetaData(), Column("name", String), Column("meta", JSON))
+
+
+class RowRules(RuleSchema):
+    name: Annotated[str, Field(pattern=r"^A")]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+
+
+engine = create_engine("sqlite:///app.db")
+event.listen(
+    engine,
+    "connect",
+    lambda dbapi_connection, _: register_sqlite_functions(dbapi_connection),
+)
+compiled = Compiler(plugins=[SQLitePlugin()]).compile(RowRules, rows)
+statement = rows.select().where(*where(compiled))
+```
+
+## Capabilities
+
+- Runtime `typeof()` checks for SQLite integer, real, and text storage classes
+- Lax text-to-int/float coercion and bool values stored as integer 0 or 1
+- JSON1 helpers that treat malformed documents as non-matches
+- `REGEXP` pattern matching and Unicode-aware string length through
+  `register_sqlite_functions()`
+
+Strict bool, exact Decimal, and SQLAlchemy-emulated date/time/UUID values need
+explicit storage adapters and raise `CapabilityError`. Text coercion, patterns,
+and string length constraints require the registered SQLRules SQLite functions
+on each connection. `register_regexp()` remains as a backward-compatible alias.
+See the
+[type support matrix](https://sqlrules.readthedocs.io/en/latest/TYPE_SUPPORT.html).
+
+## Pattern cost
+
+`register_sqlite_functions()` runs Python's `re.search` for each regex row and
+Python's `len()` for each length-checked string row. Untrusted patterns can
+cause CPU denial of service through catastrophic backtracking. Prefer static
+or allowlisted patterns. See the SQLRules
+[security notes](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

sqlrules_sqlite-2.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+sqlrules_sqlite/__init__.py,sha256=o24arJiu4TFstqKLfPL9P0TApYLexhU4V49UrM4EDKk,3253
+sqlrules_sqlite/json.py,sha256=GmRD0dKi0chsKHFazoPINR3EZrzv-mY79jlmgQKFpIQ,4548
+sqlrules_sqlite/length.py,sha256=6b2tHN0ZSKz1hLJR1UAHlJkjiYZ_5HOlAKmndOz1rdI,919
+sqlrules_sqlite/pattern.py,sha256=3G0MS429eg5ZB7txFYHdAI53qXoc7Nnu8Oe7Q3WBaHw,881
+sqlrules_sqlite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlrules_sqlite/regexp.py,sha256=sujtKjwg0EeNpc7yxCITzDkn5lhxRVt2TKUyKAD8J6Q,326
+sqlrules_sqlite/runtime.py,sha256=W-H2UeiJr2rZ8uR4AC7TmyOb7TOBEc1hh0IkD2zOSG4,1284
+sqlrules_sqlite-2.0.0.dist-info/METADATA,sha256=BtTaB1TJtxYOVKjgiutKbyE0AOIWFep0PTfkvsib9Wc,2990
+sqlrules_sqlite-2.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+sqlrules_sqlite-2.0.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
+sqlrules_sqlite-2.0.0.dist-info/RECORD,,

{sqlrules_sqlite-1.0.1.dist-info → sqlrules_sqlite-2.0.0.dist-info}/WHEEL

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

sqlrules_sqlite/type_check.py

@@ -1,213 +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 import func
-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]\d*)$"
-_FLOAT_TEXT = r"^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$"
-_DATE_TEXT = r"^\d{4}-\d{2}-\d{2}$"
-_DATETIME_TEXT = r"^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(\.\d+)?([+-]\d{2}:?\d{2}|Z)?$"
-_TIME_TEXT = r"^\d{2}:\d{2}:\d{2}(\.\d+)?$"
-_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:
-        # SQLite typeof can distinguish integer storage even on loosely typed columns.
-        return cast(ColumnElement[bool], func.typeof(column) == "integer")
-    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))
-    # Affinity-agnostic: integer typeof OR integer-shaped text.
-    return cast(
-        ColumnElement[bool],
-        (func.typeof(column) == "integer") | _regexp(column, _INT_TEXT),
-    )
-
-
-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)))
-        return cast(
-            ColumnElement[bool],
-            (func.typeof(column) == "integer") & column.in_((0, 1)),
-        )
-    _unsupported(
-        field,
-        spec,
-        "SQLite 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))
-    return cast(ColumnElement[bool], func.typeof(column) == "text")
-
-
-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:
-        return cast(
-            ColumnElement[bool],
-            func.typeof(column).in_(("real", "integer")),
-        )
-    if _is_type(column, String):
-        return _regexp(column, _FLOAT_TEXT)
-    return cast(
-        ColumnElement[bool],
-        func.typeof(column).in_(("real", "integer")) | _regexp(column, _FLOAT_TEXT),
-    )
-
-
-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 and not _is_type(column, String):
-        type_name = spec.python_type.__name__
-        _unsupported(
-            field,
-            spec,
-            f"SQLite strict {type_name} type_check requires a typed or String column.",
-        )
-    return _regexp(column, text_pattern)
-
-
-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 _is_type(column, String) or not spec.strict:
-        return _regexp(column, _UUID_TEXT)
-    _unsupported(
-        field,
-        spec,
-        "SQLite strict UUID type_check requires a UUID or String column.",
-    )
-    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"SQLite 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`` using SQLite ``typeof`` / ``REGEXP``.
-
-    Text-shape checks use ``REGEXP``; call :func:`register_regexp` on the
-    connection before executing the SQL.
-    """
-    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_sqlite-1.0.1.dist-info/METADATA

@@ -1,83 +0,0 @@
-Metadata-Version: 2.4
-Name: sqlrules-sqlite
-Version: 1.0.1
-Summary: SQLite dialect plugin for SQLRules (REGEXP helpers and JSON).
-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: pydantic,sqlalchemy,sqlite,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-sqlite
-
-SQLite dialect plugin for [SQLRules](https://github.com/eddiethedean/sqlrules).
-
-## Install
-
-```bash
-pip install sqlrules-sqlite
-```
-
-## Usage
-
-```python
-import sqlite3
-from typing import Annotated, Any
-
-from pydantic import BaseModel, Field
-from sqlalchemy import Column, MetaData, String, Table, create_engine, text
-
-from sqlrules import Compiler, JsonContains, JsonHasKey
-from sqlrules_sqlite import SQLitePlugin, register_regexp
-
-class RowFilter(BaseModel):
-    name: Annotated[str, Field(pattern=r"^A")]
-    meta: Annotated[dict[str, Any], JsonContains({"active": True}), JsonHasKey("active")]
-
-table = Table(
-    "rows",
-    MetaData(),
-    Column("name", String),
-    Column("meta", String),
-)
-
-compiler = Compiler(plugins=[SQLitePlugin()], dialect="sqlite")
-rules = compiler.compile(RowFilter, table)
-
-engine = create_engine("sqlite://")
-with engine.raw_connection() as conn:
-    # SQLAlchemy 2 may wrap the DBAPI connection; unwrap if needed.
-    dbapi = conn.driver_connection if hasattr(conn, "driver_connection") else conn
-    register_regexp(dbapi)
-```
-
-## Operators
-
-| IR operator | Notes |
-|---|---|
-| `pattern` | `column REGEXP pattern`; call `register_regexp(connection)` |
-| `type_check` | `typeof` / `REGEXP` shape checks; text forms need `register_regexp` |
-| `json_contains` | JSON1 `json_extract` equality for object keys |
-| `json_has_key` | `json_type(column, '$.key') IS NOT NULL` |
-
-Case-insensitive patterns (`re.IGNORECASE` / `PatternSpec.ignore_case`) are
-encoded with a `(?i)` prefix understood by `register_regexp`.
-
-## Security note
-
-`register_regexp` installs a Python `re.search` UDF. Untrusted
-`Field(pattern=...)` values can cause **CPU denial of service** (ReDoS) in
-your process — not SQL injection. Prefer static/allowlisted patterns. See
-[SECURITY](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

sqlrules_sqlite-1.0.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-sqlrules_sqlite/__init__.py,sha256=oLODNHzgXbK1XjmI5YcpnDKf7JXYJfj0Wr2Gcnc35ds,1575
-sqlrules_sqlite/json.py,sha256=B9QCjD8FR7nja8Ct4O7fb2VzTPhALg3b_ODayBeKHBY,3326
-sqlrules_sqlite/pattern.py,sha256=K1JBoM1bkxYRgWKz_Ti7o_IDFKtIeg9uYplr0ThVJBY,867
-sqlrules_sqlite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlrules_sqlite/regexp.py,sha256=j3c_J3dnbAdXfKkhhb1CxiIPi1QB_ai5Mt30ODrmx3M,1038
-sqlrules_sqlite/type_check.py,sha256=JQXzgdLWmdAnGXOBPza4yMwVhrWWeYyforv-hQSd9k4,6742
-sqlrules_sqlite-1.0.1.dist-info/METADATA,sha256=yCg5Z14W7BSP9IquHzYJFKuu-oUzzHdDooT1R0qKnzU,2694
-sqlrules_sqlite-1.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-sqlrules_sqlite-1.0.1.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
-sqlrules_sqlite-1.0.1.dist-info/RECORD,,