sqlrules-sqlite 1.0.1__tar.gz

sqlrules_sqlite-1.0.1/.gitignore

@@ -0,0 +1,22 @@
+.venv/
+venv/
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+dist/
+dist-plugins/
+dist-missing/
+build/
+*.egg-info/
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
+docs/_build/

sqlrules_sqlite-1.0.1/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.

sqlrules_sqlite-1.0.1/PKG-INFO

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

@@ -0,0 +1,61 @@
+# 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/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sqlrules-sqlite"
+version = "1.0.1"
+description = "SQLite dialect plugin for SQLRules (REGEXP helpers and JSON)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "SQLRules Contributors" }]
+keywords = ["sqlrules", "sqlite", "pydantic", "sqlalchemy"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Typing :: Typed",
+]
+dependencies = [
+  "sqlrules>=1,<2",
+  "sqlalchemy>=2.0,<3",
+]
+
+[project.urls]
+Homepage = "https://github.com/eddiethedean/sqlrules"
+Repository = "https://github.com/eddiethedean/sqlrules"
+Issues = "https://github.com/eddiethedean/sqlrules/issues"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/tests",
+  "/README.md",
+  "/LICENSE",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sqlrules_sqlite"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

sqlrules_sqlite-1.0.1/src/sqlrules_sqlite/__init__.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+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.pattern import translate_pattern
+from sqlrules_sqlite.regexp import register_regexp
+from sqlrules_sqlite.type_check import translate_type_check
+
+__version__ = "1.0.1"
+
+
+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.
+    """
+
+    name = "sqlite"
+    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",
+        )
+        registry.register_constraint(
+            "json_contains",
+            translate_json_contains,
+            on_conflict="replace",
+        )
+        registry.register_constraint(
+            "json_has_key",
+            translate_json_has_key,
+            on_conflict="replace",
+        )
+
+
+__all__ = [
+    "SQLitePlugin",
+    "__version__",
+    "register_regexp",
+    "translate_json_contains",
+    "translate_json_has_key",
+    "translate_pattern",
+    "translate_type_check",
+]

sqlrules_sqlite-1.0.1/src/sqlrules_sqlite/json.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import json
+from typing import Any, cast
+
+from sqlalchemy import String, func, literal, type_coerce
+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 _compact_dumps(value: Any) -> str:
+    return json.dumps(value, separators=(",", ":"))
+
+
+def _extract_equals(
+    column: ColumnElement[Any],
+    path: str,
+    expected: Any,
+) -> ColumnElement[bool]:
+    """Compare ``json_extract`` to ``expected`` using SQLite JSON1 affinities."""
+    extracted = func.json_extract(column, path)
+    if expected is None:
+        return cast(ColumnElement[bool], func.json_type(column, path) == "null")
+    if isinstance(expected, bool):
+        return cast(ColumnElement[bool], extracted == (1 if expected else 0))
+    if isinstance(expected, (dict, list)):
+        compact = _compact_dumps(expected)
+        return cast(
+            ColumnElement[bool],
+            func.json(extracted) == func.json(literal(compact)),
+        )
+    if isinstance(expected, (int, float)):
+        return cast(ColumnElement[bool], extracted == expected)
+    if isinstance(expected, str):
+        return cast(ColumnElement[bool], extracted == expected)
+    compact = _compact_dumps(expected)
+    return cast(
+        ColumnElement[bool],
+        func.json(extracted) == func.json(literal(compact)),
+    )
+
+
+def translate_json_contains(
+    constraint: Constraint,
+    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.
+    """
+    value = constraint.value
+    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"),
+            )
+        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)
+    return cast(
+        ColumnElement[bool],
+        func.json(type_coerce(column, String)) == func.json(literal(compact)),
+    )
+
+
+def translate_json_has_key(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``json_has_key`` via ``json_type(column, path) IS NOT NULL``."""
+    path = _json_path_for_key(constraint.value)
+    return cast(ColumnElement[bool], func.json_type(column, path).is_not(None))

sqlrules_sqlite-1.0.1/src/sqlrules_sqlite/pattern.py

@@ -0,0 +1,25 @@
+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 SQLite ``column REGEXP pattern``.
+
+    Case-insensitive patterns are encoded with a ``(?i)`` prefix so
+    :func:`sqlrules_sqlite.register_regexp` can apply ``re.IGNORECASE``.
+    Callers must enable REGEXP on the SQLite connection before execution.
+    """
+    pattern, ignore_case = pattern_text(constraint.value)
+    if ignore_case and not pattern.startswith("(?i)"):
+        pattern = f"(?i){pattern}"
+    return cast(ColumnElement[bool], column.op("REGEXP")(pattern))

sqlrules_sqlite-1.0.1/src/sqlrules_sqlite/regexp.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import re
+import sqlite3
+
+
+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 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)

sqlrules_sqlite-1.0.1/src/sqlrules_sqlite/type_check.py

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

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+import re
+import sqlite3
+from typing import Annotated, Any
+
+import pytest
+from pydantic import BaseModel, Field
+from sqlalchemy import Column, MetaData, String, Table, create_engine, select
+from sqlalchemy.dialects import sqlite
+from sqlrules_sqlite import SQLitePlugin, __version__, register_regexp
+
+from sqlrules import Compiler, JsonContains, JsonHasKey
+from sqlrules.conformance import run_basic_conformance
+
+
+def test_version() -> None:
+    assert __version__ == "1.0.1"
+
+
+def test_conformance() -> None:
+    run_basic_conformance(SQLitePlugin(), operator="pattern")
+
+
+def test_pattern_compiles() -> None:
+    """SQLite REGEXP uses ``re.search`` (not Pydantic fullmatch); anchors are caller-owned."""
+
+    class Filter(BaseModel):
+        name: Annotated[str, Field(pattern=r"^A")]
+
+    table = Table("items", MetaData(), Column("name", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(
+        rules["name"][0].compile(
+            dialect=sqlite.dialect(),
+            compile_kwargs={"literal_binds": True},
+        )
+    )
+    assert compiled == "items.name REGEXP '^A'"
+
+
+def test_pattern_ignore_case_prefix() -> None:
+    class Filter(BaseModel):
+        name: Annotated[str, Field(pattern=re.compile(r"^A", re.I))]
+
+    table = Table("items", MetaData(), Column("name", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(rules["name"][0].compile(compile_kwargs={"literal_binds": True}))
+    assert compiled == "items.name REGEXP '(?i)^A'"
+
+
+def test_register_regexp_null_inputs_are_false() -> None:
+    conn = sqlite3.connect(":memory:")
+    register_regexp(conn)
+    assert conn.execute("SELECT NULL REGEXP '^a'").fetchone()[0] == 0
+    assert conn.execute("SELECT 'Abc' REGEXP NULL").fetchone()[0] == 0
+    conn.close()
+
+
+def test_register_regexp_matches() -> None:
+    conn = sqlite3.connect(":memory:")
+    register_regexp(conn)
+    assert conn.execute("SELECT 'Abc' REGEXP '(?i)^a'").fetchone()[0] == 1
+    assert conn.execute("SELECT 'Abc' REGEXP '^a'").fetchone()[0] == 0
+    # Empty pattern: re.search('', value) is True for any string.
+    assert conn.execute("SELECT 'Abc' REGEXP ''").fetchone()[0] == 1
+    conn.close()
+
+
+def test_pattern_translator_with_register_regexp_executes() -> None:
+    class Filter(BaseModel):
+        name: Annotated[str, Field(pattern=re.compile(r"^a", re.I))]
+
+    metadata = MetaData()
+    table = Table("items", metadata, Column("name", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        cache=False,
+    ).compile(Filter, table)
+
+    engine = create_engine("sqlite://")
+    with engine.begin() as conn:
+        raw = conn.connection.dbapi_connection
+        register_regexp(raw)  # type: ignore[arg-type]
+        metadata.create_all(conn)
+        conn.execute(table.insert(), [{"name": "Abc"}, {"name": "zzz"}])
+        stmt = select(table.c.name).where(*rules["name"])
+        rows = [row[0] for row in conn.execute(stmt)]
+    assert rows == ["Abc"]
+
+
+def test_json_operators_compile() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[dict[str, Any], JsonContains({"active": True}), JsonHasKey("active")]
+
+    table = Table("items", MetaData(), Column("meta", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        cache=False,
+    ).compile(Filter, table)
+    assert len(rules["meta"]) == 2
+    contains_sql = str(rules["meta"][0].compile(dialect=sqlite.dialect())).lower()
+    has_key_sql = str(rules["meta"][1].compile(dialect=sqlite.dialect())).lower()
+    assert "json_extract" in contains_sql
+    assert "json_type" in has_key_sql
+    assert "json_extract" not in has_key_sql
+
+
+def test_json_contains_executes_for_bool_str_int_null() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[
+            dict[str, Any],
+            JsonContains({"active": True, "name": "hello", "n": 1, "missing": None}),
+        ]
+
+    metadata = MetaData()
+    table = Table("items", metadata, Column("id", String), Column("meta", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        cache=False,
+    ).compile(Filter, table)
+
+    engine = create_engine("sqlite://")
+    with engine.begin() as conn:
+        metadata.create_all(conn)
+        conn.execute(
+            table.insert(),
+            [
+                {
+                    "id": "match",
+                    "meta": '{"active": true, "name": "hello", "n": 1, "missing": null}',
+                },
+                {
+                    "id": "partial",
+                    "meta": '{"active": true, "name": "hello", "n": 2}',
+                },
+                {"id": "null", "meta": None},
+            ],
+        )
+        rows = [
+            row[0]
+            for row in conn.execute(select(table.c.id).where(*rules["meta"]).order_by(table.c.id))
+        ]
+    assert rows == ["match"]
+
+
+def test_json_contains_dotted_key_and_array_payload() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[dict[str, Any], JsonContains({"a.b": 1})]
+        tags: Annotated[list[Any], JsonContains([1, 2])]
+
+    metadata = MetaData()
+    table = Table(
+        "items",
+        metadata,
+        Column("id", String),
+        Column("meta", String),
+        Column("tags", String),
+    )
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        cache=False,
+    ).compile(Filter, table)
+
+    engine = create_engine("sqlite://")
+    with engine.begin() as conn:
+        metadata.create_all(conn)
+        conn.execute(
+            table.insert(),
+            [
+                {"id": "match", "meta": '{"a.b": 1}', "tags": "[1,2]"},
+                {"id": "nested", "meta": '{"a": {"b": 1}}', "tags": "[1,2]"},
+                {"id": "spaced", "meta": '{"a.b": 1}', "tags": "[1, 2]"},
+            ],
+        )
+        meta_rows = [
+            row[0]
+            for row in conn.execute(select(table.c.id).where(*rules["meta"]).order_by(table.c.id))
+        ]
+        tag_rows = [
+            row[0]
+            for row in conn.execute(select(table.c.id).where(*rules["tags"]).order_by(table.c.id))
+        ]
+    assert meta_rows == ["match", "spaced"]
+    assert tag_rows == ["match", "nested", "spaced"]
+
+
+def test_empty_json_contains_requires_object() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[dict[str, Any], JsonContains({})]
+
+    metadata = MetaData()
+    table = Table("items", metadata, Column("id", String), Column("meta", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(
+        rules["meta"][0].compile(
+            dialect=sqlite.dialect(),
+            compile_kwargs={"literal_binds": True},
+        )
+    ).lower()
+    assert "json_type" in compiled
+    assert "object" in compiled
+
+    engine = create_engine("sqlite://")
+    with engine.begin() as conn:
+        metadata.create_all(conn)
+        conn.execute(
+            table.insert(),
+            [
+                {"id": "obj", "meta": "{}"},
+                {"id": "arr", "meta": "[]"},
+                {"id": "null", "meta": None},
+            ],
+        )
+        rows = [
+            row[0]
+            for row in conn.execute(select(table.c.id).where(*rules["meta"]).order_by(table.c.id))
+        ]
+    assert rows == ["obj"]
+
+
+def test_register_regexp_invalid_pattern_raises() -> None:
+    conn = sqlite3.connect(":memory:")
+    register_regexp(conn)
+    with pytest.raises(sqlite3.OperationalError):
+        conn.execute("SELECT 'Abc' REGEXP '['").fetchone()
+    conn.close()
+
+
+def test_type_check_int_integer_column() -> None:
+    from sqlalchemy import Integer
+
+    class Filter(BaseModel):
+        age: int
+
+    table = Table("users", MetaData(), Column("age", Integer))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        emit_type_checks=True,
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(rules["age"][0].compile(dialect=sqlite.dialect()))
+    assert "IS NOT NULL" in compiled.upper()
+
+
+def test_type_check_lax_int_string_uses_regexp() -> None:
+    class Filter(BaseModel):
+        age: int
+
+    table = Table("rows", MetaData(), Column("age", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        emit_type_checks=True,
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(
+        rules["age"][0].compile(
+            dialect=sqlite.dialect(),
+            compile_kwargs={"literal_binds": True},
+        )
+    )
+    assert "REGEXP" in compiled
+    assert "rows.age" in compiled
+
+
+def test_type_check_lax_int_string_executes_with_register_regexp() -> None:
+    class Filter(BaseModel):
+        age: int
+
+    metadata = MetaData()
+    table = Table("rows", metadata, Column("id", String), Column("age", String))
+    rules = Compiler(
+        plugins=[SQLitePlugin()],
+        dialect="sqlite",
+        emit_type_checks=True,
+        cache=False,
+    ).compile(Filter, table)
+
+    engine = create_engine("sqlite://")
+    with engine.begin() as conn:
+        raw = conn.connection.dbapi_connection
+        register_regexp(raw)  # type: ignore[arg-type]
+        metadata.create_all(conn)
+        conn.execute(
+            table.insert(),
+            [
+                {"id": "ok", "age": "42"},
+                {"id": "bad", "age": "x"},
+                {"id": "null", "age": None},
+            ],
+        )
+        rows = [
+            row[0]
+            for row in conn.execute(select(table.c.id).where(*rules["age"]).order_by(table.c.id))
+        ]
+    assert rows == ["ok"]