sqlrules 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

sqlrules/__init__.py

@@ -18,27 +18,47 @@ from sqlrules.ir import (
     FieldDescriptor,
     FieldIR,
     ModelIR,
+    PatternSpec,
+)
+from sqlrules.markers import (
+    ArrayContains,
+    ArrayOverlap,
+    ConstraintMarker,
+    FullTextMatch,
+    JsonContains,
+    JsonHasKey,
+    RangeContains,
+    RangeOverlap,
 )
 from sqlrules.plugins import PLUGIN_API_VERSION, SQLRulesPlugin
 from sqlrules.translators import SQLRulesWarning
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 __all__ = [
     "PLUGIN_API_VERSION",
+    "ArrayContains",
+    "ArrayOverlap",
     "CompilationContext",
     "Compiler",
     "ConfigurationError",
     "Constraint",
+    "ConstraintMarker",
     "Diagnostic",
     "FieldDescriptor",
     "FieldIR",
+    "FullTextMatch",
     "InternalCompilerError",
     "InvalidModelError",
     "InvalidTranslatorError",
+    "JsonContains",
+    "JsonHasKey",
     "MissingColumnError",
     "ModelIR",
+    "PatternSpec",
     "PluginError",
+    "RangeContains",
+    "RangeOverlap",
     "RegistryError",
     "SQLRulesError",
     "SQLRulesPlugin",

sqlrules/conformance.py

@@ -108,15 +108,23 @@ def assert_translates_operator(
             f"returned {type(expression)!r}, expected ColumnElement"
         )
 
-    # Deterministic compile smoke check (dialect-neutral string form).
-    compiled_a = str(expression.compile(compile_kwargs={"literal_binds": True}))
-    compiled_b = str(expression.compile(compile_kwargs={"literal_binds": True}))
+    # Deterministic compile smoke check (avoid literal_binds; values may be
+    # structured IR objects such as PatternSpec).
+    compiled_a = str(expression.compile())
+    compiled_b = str(expression.compile())
     if compiled_a != compiled_b:
         raise AssertionError(f"Plugin {plugin.name!r}: non-deterministic compile for {operator!r}")
     return expression
 
 
-def run_basic_conformance(plugin: SQLRulesPlugin, *, operator: str = "pattern") -> None:
+def run_basic_conformance(
+    plugin: SQLRulesPlugin,
+    *,
+    operator: str = "pattern",
+    model: type[BaseModel] | None = None,
+    table: Any | None = None,
+    field: str = "name",
+) -> None:
     """Run the standard conformance checks for a dialect/translator plugin."""
     if getattr(plugin, "api_version", None) != PLUGIN_API_VERSION:
         raise PluginError(
@@ -129,7 +137,13 @@ def run_basic_conformance(plugin: SQLRulesPlugin, *, operator: str = "pattern")
     assert_plugin_api_compatible(plugin)
     assert_builtins_preserved(plugin, on_conflict="replace")
     assert_register_idempotent_ignore(plugin)
-    assert_translates_operator(plugin, operator=operator)
+    assert_translates_operator(
+        plugin,
+        operator=operator,
+        model=model,
+        table=table,
+        field=field,
+    )
 
     # Conflict under raise: only meaningful if the plugin re-registers an op
     # already present after the first registration.

sqlrules/constraints.py

@@ -22,15 +22,18 @@ from annotated_types import (
 from pydantic.fields import FieldInfo
 
 from sqlrules.errors import UnsupportedConstraintError
-from sqlrules.ir import Constraint, FieldDescriptor
+from sqlrules.ir import Constraint, FieldDescriptor, PatternSpec
+from sqlrules.markers import ConstraintMarker
 
 _SUPPORTED_TYPES: frozenset[type[Any]] = frozenset(
     {bool, int, float, Decimal, str, date, datetime, time, UUID}
 )
+_SUPPORTED_CONTAINER_ORIGINS: frozenset[Any] = frozenset({list, dict})
 _UNSUPPORTED_TYPES: frozenset[type[Any]] = frozenset({timedelta})
-_UNSUPPORTED_ORIGINS: frozenset[Any] = frozenset({list, dict, tuple, set, frozenset})
+_UNSUPPORTED_ORIGINS: frozenset[Any] = frozenset({tuple, set, frozenset})
 _LENGTH_OPERATORS: frozenset[str] = frozenset({"min_length", "max_length"})
 _NUMERIC_OPERATORS: frozenset[str] = frozenset({"gt", "ge", "lt", "le", "multiple_of"})
+_PORTABLE_OPERATORS: frozenset[str] = _LENGTH_OPERATORS | _NUMERIC_OPERATORS | {"pattern"}
 _TEMPORAL_TYPES: frozenset[type[Any]] = frozenset({date, datetime, time})
 _VALIDATOR_TYPE_NAMES = frozenset(
     {
@@ -126,6 +129,13 @@ def _concrete_type(field: FieldDescriptor) -> Any:
     return annotation
 
 
+def _is_container_type(annotation: Any) -> bool:
+    origin = get_origin(annotation)
+    if origin in _SUPPORTED_CONTAINER_ORIGINS:
+        return True
+    return annotation in _SUPPORTED_CONTAINER_ORIGINS
+
+
 def ensure_supported_type(field: FieldDescriptor) -> None:
     """Raise when a field annotation is outside the support matrix."""
     annotation = _concrete_type(field)
@@ -134,16 +144,20 @@ def ensure_supported_type(field: FieldDescriptor) -> None:
     if origin is Literal:
         return
 
-    if origin in _UNSUPPORTED_ORIGINS:
+    if origin in _UNSUPPORTED_ORIGINS or annotation in _UNSUPPORTED_ORIGINS:
         raise UnsupportedConstraintError(
             field=field.name,
-            operator=getattr(origin, "__name__", str(origin)),
+            operator=getattr(origin or annotation, "__name__", str(origin or annotation)),
             value=annotation,
             suggestion=(
-                "Remove the field or wait for a future SQLRules release with container support."
+                "Remove the field or wait for a future SQLRules release with "
+                f"{getattr(origin or annotation, '__name__', origin or annotation)!r} support."
             ),
         )
 
+    if _is_container_type(annotation):
+        return
+
     if isinstance(annotation, type) and issubclass(annotation, Enum):
         return
 
@@ -171,11 +185,16 @@ def ensure_supported_type(field: FieldDescriptor) -> None:
     )
 
 
-def _normalize_pattern(field_name: str, pattern: Any) -> str:
-    if isinstance(pattern, str):
+def _normalize_pattern(field_name: str, pattern: Any) -> PatternSpec:
+    if isinstance(pattern, PatternSpec):
         return pattern
+    if isinstance(pattern, str):
+        return PatternSpec(pattern=pattern, ignore_case=False)
     if isinstance(pattern, re.Pattern):
-        return str(pattern.pattern)
+        return PatternSpec(
+            pattern=str(pattern.pattern),
+            ignore_case=bool(pattern.flags & re.IGNORECASE),
+        )
     raise UnsupportedConstraintError(
         field=field_name,
         operator="pattern",
@@ -184,6 +203,15 @@ def _normalize_pattern(field_name: str, pattern: Any) -> str:
     )
 
 
+def pattern_text(value: Any) -> tuple[str, bool]:
+    """Return ``(pattern, ignore_case)`` from a ``pattern`` constraint value."""
+    if isinstance(value, PatternSpec):
+        return value.pattern, value.ignore_case
+    if isinstance(value, str):
+        return value, False
+    raise TypeError(f"pattern value must be str or PatternSpec, got {type(value)!r}")
+
+
 def _constraints_from_mapping(field_name: str, data: dict[str, Any]) -> list[Constraint]:
     """Map whitelisted metadata keys into IR; ignore validation-only flags."""
     constraints: list[Constraint] = []
@@ -202,7 +230,16 @@ def _constraints_from_mapping(field_name: str, data: dict[str, Any]) -> list[Con
     return constraints
 
 
+def _is_constraint_marker(item: Any) -> bool:
+    if isinstance(item, type):
+        return False
+    return isinstance(item, ConstraintMarker)
+
+
 def _unsupported_constraints(field_name: str, item: Any) -> list[Constraint]:
+    if _is_constraint_marker(item):
+        return [Constraint(field_name, item.operator, item.value)]
+
     if isinstance(item, Predicate):
         return [Constraint(field_name, "predicate", item.func)]
 
@@ -218,7 +255,7 @@ def _unsupported_constraints(field_name: str, item: Any) -> list[Constraint]:
 
     # First-class pattern attribute (e.g. _PydanticGeneralMetadata(pattern=...)).
     pattern = getattr(item, "pattern", None)
-    if pattern is not None and isinstance(pattern, (str, re.Pattern)):
+    if pattern is not None and isinstance(pattern, (str, re.Pattern, PatternSpec)):
         constraints = _constraints_from_mapping(
             field_name,
             {
@@ -243,6 +280,17 @@ def _reject_type_operator_mismatch(field: FieldDescriptor, constraint: Constrain
     annotation = _concrete_type(field)
     origin = get_origin(annotation)
 
+    if _is_container_type(annotation) and constraint.operator in _PORTABLE_OPERATORS:
+        raise UnsupportedConstraintError(
+            field=field.name,
+            operator=constraint.operator,
+            value=constraint.value,
+            suggestion=(
+                "Portable constraints are not valid on list/dict fields; "
+                "use sqlrules.markers (e.g. JsonContains, ArrayContains) instead."
+            ),
+        )
+
     if origin is Literal:
         if (
             constraint.operator not in {"literal", "enum"}
@@ -322,7 +370,9 @@ def extract_constraints(field: FieldDescriptor) -> list[Constraint]:
     constraints: list[Constraint] = []
 
     for item in _iter_metadata(_field_metadata(field)):
-        if isinstance(item, Gt):
+        if _is_constraint_marker(item):
+            constraints.append(Constraint(field.name, item.operator, item.value))
+        elif isinstance(item, Gt):
             constraints.append(Constraint(field.name, "gt", item.gt))
         elif isinstance(item, Ge):
             constraints.append(Constraint(field.name, "ge", item.ge))
@@ -351,7 +401,7 @@ def extract_constraints(field: FieldDescriptor) -> list[Constraint]:
         constraints.append(Constraint(field.name, "enum", values))
 
     for constraint in constraints:
-        if constraint.operator in _LENGTH_OPERATORS | _NUMERIC_OPERATORS | {"pattern"}:
+        if constraint.operator in _PORTABLE_OPERATORS:
             _reject_type_operator_mismatch(field, constraint)
 
     return constraints

sqlrules/ir.py

@@ -8,6 +8,14 @@ OnConflict = Literal["raise", "replace", "ignore"]
 DiagnosticSeverity = Literal["warning", "info"]
 
 
+@dataclass(frozen=True, slots=True)
+class PatternSpec:
+    """Normalized ``pattern`` constraint value (preserves case-folding intent)."""
+
+    pattern: str
+    ignore_case: bool = False
+
+
 @dataclass(frozen=True, slots=True)
 class Constraint:
     field: str

sqlrules/markers.py

@@ -0,0 +1,86 @@
+"""Dialect-oriented constraint markers for Annotated metadata.
+
+Markers are extracted into IR as ``Constraint(field, marker.operator, marker.value)``.
+Core does not translate these operators; dialect plugins register translators.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ConstraintMarker(Protocol):
+    """Protocol for Annotated metadata that becomes a SQLRules IR constraint."""
+
+    operator: str
+    value: Any
+
+
+@dataclass(frozen=True, slots=True)
+class JsonContains:
+    """Require JSON/JSONB containment (``json_contains``)."""
+
+    value: Any
+    operator: str = field(default="json_contains", init=False, repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class JsonHasKey:
+    """Require a JSON object key (``json_has_key``)."""
+
+    value: Any
+    operator: str = field(default="json_has_key", init=False, repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class ArrayContains:
+    """Require array containment (``array_contains``)."""
+
+    value: Any
+    operator: str = field(default="array_contains", init=False, repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class ArrayOverlap:
+    """Require array overlap (``array_overlap``)."""
+
+    value: Any
+    operator: str = field(default="array_overlap", init=False, repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class RangeContains:
+    """Require range containment (``range_contains``)."""
+
+    value: Any
+    operator: str = field(default="range_contains", init=False, repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class RangeOverlap:
+    """Require range overlap (``range_overlap``)."""
+
+    value: Any
+    operator: str = field(default="range_overlap", init=False, repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class FullTextMatch:
+    """Require a full-text match (``fulltext_match``)."""
+
+    value: Any
+    operator: str = field(default="fulltext_match", init=False, repr=False)
+
+
+__all__ = [
+    "ArrayContains",
+    "ArrayOverlap",
+    "ConstraintMarker",
+    "FullTextMatch",
+    "JsonContains",
+    "JsonHasKey",
+    "RangeContains",
+    "RangeOverlap",
+]

{sqlrules-0.3.0.dist-info → sqlrules-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrules
-Version: 0.3.0
+Version: 0.4.0
 Summary: Compile constrained Pydantic models into SQLAlchemy WHERE-rule dictionaries.
 Project-URL: Homepage, https://github.com/eddiethedean/sqlrules
 Project-URL: Documentation, https://github.com/eddiethedean/sqlrules#readme
@@ -84,19 +84,27 @@ Requires Python 3.10+, Pydantic v2, and SQLAlchemy 2.x.
 Optional dialect plugins:
 
 ```bash
-pip install sqlrules-postgresql   # pattern → PostgreSQL ~
-pip install sqlrules-sqlite       # pattern → SQLite REGEXP
+pip install sqlrules-postgresql   # ~ / ~*, JSONB, ARRAY, range
+pip install sqlrules-sqlite       # REGEXP helper + JSON
+pip install sqlrules-mysql        # REGEXP, JSON, full-text
+pip install sqlrules-mssql        # JSON + LEN string ops
 ```
 
 ```python
-from sqlrules import Compiler
+from typing import Annotated, Any
+from pydantic import BaseModel, Field
+from sqlrules import Compiler, JsonContains
 from sqlrules_postgresql import PostgresPlugin
 
+class RowFilter(BaseModel):
+    name: Annotated[str, Field(pattern=r"^A")]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+
 compiler = Compiler(plugins=[PostgresPlugin()], dialect="postgresql")
-rules = compiler.compile(UserFilter, users)
+rules = compiler.compile(RowFilter, table)
 ```
 
-## Supported constraints (0.3)
+## Supported constraints (0.4)
 
 | Constraint | SQLAlchemy expression |
 |---|---|
@@ -106,9 +114,11 @@ rules = compiler.compile(UserFilter, users)
 | `Literal[...]` | `column.in_(...)` |
 | `Enum` | `column.in_(...)` |
 
-`pattern` is extracted into IR but has no portable core translator.
-Use a custom registry translator or a dialect plugin
-(`sqlrules-postgresql`, `sqlrules-sqlite`).
+`pattern` is extracted into IR (`PatternSpec`) but has no portable core
+translator. Use a dialect plugin or a custom registry translator.
+
+Dialect markers (`JsonContains`, `ArrayContains`, `RangeContains`,
+`FullTextMatch`, …) live in `sqlrules.markers` and require a dialect plugin.
 
 Unsupported constraints raise `UnsupportedConstraintError` by default.
 Use `on_unsupported="warn"` or `"ignore"` to change that policy for unknown
@@ -147,8 +157,10 @@ and [roadmap](docs/ROADMAP.md).
 
 ```bash
 pip install -e ".[dev]"
-pip install -e packages/sqlrules-postgresql -e packages/sqlrules-sqlite
-pytest tests packages/sqlrules-postgresql/tests packages/sqlrules-sqlite/tests
+pip install -e packages/sqlrules-postgresql -e packages/sqlrules-sqlite \
+  -e packages/sqlrules-mysql -e packages/sqlrules-mssql
+pytest tests packages/sqlrules-postgresql/tests packages/sqlrules-sqlite/tests \
+  packages/sqlrules-mysql/tests packages/sqlrules-mssql/tests
 ruff check .
 mypy src/sqlrules
 python -m benchmarks.bench_compile

{sqlrules-0.3.0.dist-info → sqlrules-0.4.0.dist-info}/RECORD

@@ -1,16 +1,17 @@
-sqlrules/__init__.py,sha256=IEIU4ESvzydICwS2CnqXzIz9KA5PiQvHw-FlMybfkvM,1130
+sqlrules/__init__.py,sha256=60Wwpv204ZOs36qCHvRWD8r8ZYLvAS3qunLvB3qSWNY,1513
 sqlrules/cache.py,sha256=9NBDunUMvQR3bsx9QxIiO8L8JNbpI1tdLlFNapUZMj8,1051
 sqlrules/columns.py,sha256=TcDhFG8wxgKC3-kwXhOBP27Ekrlfncm-WWrUkMLCplo,2428
 sqlrules/compiler.py,sha256=sVlpcP5qv-BUjKSNwd4Q6I3aQvqVOgDo89EAwxTqo5I,6799
-sqlrules/conformance.py,sha256=QV3lTfVtj0vcWUfP8NO_RD7HBon-sANSGdIpVttn_xM,5469
-sqlrules/constraints.py,sha256=YcI2TstNoW9GGR4TfoWBzMlmKKNPsqNjTdUr3Cd3rk8,12349
+sqlrules/conformance.py,sha256=WZfjnv3JfQZ2J93VE3kBD8AFlrz0DX6XjuZ7Z_0D0I0,5646
+sqlrules/constraints.py,sha256=nHuX2xuoSnyx-l6D6hk8Ncb946r_IkehtQ2iumbmbzs,14346
 sqlrules/errors.py,sha256=qcSCcnL19kvfzAd1eMN1pVVNbV3cg1WLb94uGna8w-M,2989
 sqlrules/inspectors.py,sha256=mEi7ixA1aQe7lyZtcFvLHVqVsAXt_tm60YNgJrYbrp8,1700
-sqlrules/ir.py,sha256=ekZ6HLxrJofGvlxZwh2BZty5oV1uzJQjSfZf0GXb6z8,2097
+sqlrules/ir.py,sha256=jUw8BjZeTBHt5o0KcwBfbUfC7VlcEl4McQahTfZ0DAA,2285
+sqlrules/markers.py,sha256=mAFlZYn050wCKCungONWawIvnYlXTF7aG_VzZ7Hz5GQ,2159
 sqlrules/plugins.py,sha256=ClXVdISpgNzVQkQCJk9ptgnXxqWLwi99EBcNP9wYXyI,1740
 sqlrules/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlrules/translators.py,sha256=aw8Q8hgfNUqdUEosUXgMW4IqTTBNUtSA-Yc2aCiPKNs,7949
-sqlrules-0.3.0.dist-info/METADATA,sha256=DcOg6uAGJlk2brXQloOv09vEWJbBvOfu1EfMsP9mlAY,4898
-sqlrules-0.3.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-sqlrules-0.3.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
-sqlrules-0.3.0.dist-info/RECORD,,
+sqlrules-0.4.0.dist-info/METADATA,sha256=icGrZdcSygSpxjeX-rYsDJvRYy6xGA0owVvXQf0yy2Y,5485
+sqlrules-0.4.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sqlrules-0.4.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
+sqlrules-0.4.0.dist-info/RECORD,,