sqlrules-postgresql 1.0.1__tar.gz → 2.0.0__tar.gz

sqlrules_postgresql-2.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.5
+Name: sqlrules-postgresql
+Version: 2.0.0
+Summary: PostgreSQL dialect plugin for SQLRules (regex, JSONB, ARRAY, range).
+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: postgresql,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-postgresql
+
+PostgreSQL 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-postgresql>=2,<3"
+```
+
+## Use
+
+```python
+from typing import Annotated, Any
+
+from pydantic import Field
+from sqlalchemy import Column, MetaData, String, Table
+from sqlalchemy.dialects.postgresql import ARRAY, INT4RANGE, JSONB
+
+from sqlrules import ArrayContains, Compiler, JsonContains, RangeContains, RuleSchema, where
+from sqlrules_postgresql import PostgresPlugin
+
+rows = Table(
+    "rows",
+    MetaData(),
+    Column("name", String),
+    Column("meta", JSONB),
+    Column("tags", ARRAY(String)),
+    Column("span", INT4RANGE),
+)
+
+
+class RowRules(RuleSchema):
+    name: Annotated[str, Field(pattern=r"^A")]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+    tags: Annotated[list[str], ArrayContains(["admin"])]
+    span: Annotated[int, RangeContains(5)]
+
+
+compiled = Compiler(plugins=[PostgresPlugin(server_version=(16, 0))]).compile(RowRules, rows)
+statement = rows.select().where(*where(compiled))
+```
+
+## Capabilities
+
+- `pattern`: PostgreSQL `~` / `~*`
+- JSONB containment and key membership
+- ARRAY containment and overlap
+- Range containment and overlap
+- Safe lax text-to-int/float/Decimal parsing on PostgreSQL 16+
+
+String Literal and Enum fields require a column with `C` or `POSIX`
+collation. Review the [type support matrix](https://sqlrules.readthedocs.io/en/latest/TYPE_SUPPORT.html)
+for the exact conversion profile and limitations.
+
+## Pattern cost
+
+Untrusted regular expressions can cause expensive engine-side evaluation.
+Prefer patterns authored with the rule model. See the SQLRules
+[security notes](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

sqlrules_postgresql-2.0.0/README.md

@@ -0,0 +1,61 @@
+# sqlrules-postgresql
+
+PostgreSQL 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-postgresql>=2,<3"
+```
+
+## Use
+
+```python
+from typing import Annotated, Any
+
+from pydantic import Field
+from sqlalchemy import Column, MetaData, String, Table
+from sqlalchemy.dialects.postgresql import ARRAY, INT4RANGE, JSONB
+
+from sqlrules import ArrayContains, Compiler, JsonContains, RangeContains, RuleSchema, where
+from sqlrules_postgresql import PostgresPlugin
+
+rows = Table(
+    "rows",
+    MetaData(),
+    Column("name", String),
+    Column("meta", JSONB),
+    Column("tags", ARRAY(String)),
+    Column("span", INT4RANGE),
+)
+
+
+class RowRules(RuleSchema):
+    name: Annotated[str, Field(pattern=r"^A")]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+    tags: Annotated[list[str], ArrayContains(["admin"])]
+    span: Annotated[int, RangeContains(5)]
+
+
+compiled = Compiler(plugins=[PostgresPlugin(server_version=(16, 0))]).compile(RowRules, rows)
+statement = rows.select().where(*where(compiled))
+```
+
+## Capabilities
+
+- `pattern`: PostgreSQL `~` / `~*`
+- JSONB containment and key membership
+- ARRAY containment and overlap
+- Range containment and overlap
+- Safe lax text-to-int/float/Decimal parsing on PostgreSQL 16+
+
+String Literal and Enum fields require a column with `C` or `POSIX`
+collation. Review the [type support matrix](https://sqlrules.readthedocs.io/en/latest/TYPE_SUPPORT.html)
+for the exact conversion profile and limitations.
+
+## Pattern cost
+
+Untrusted regular expressions can cause expensive engine-side evaluation.
+Prefer patterns authored with the rule model. See the SQLRules
+[security notes](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

{sqlrules_postgresql-1.0.1 → sqlrules_postgresql-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlrules-postgresql"
-version = "1.0.1"
+version = "2.0.0"
 description = "PostgreSQL dialect plugin for SQLRules (regex, JSONB, ARRAY, range)."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -18,7 +18,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "sqlrules>=1,<2",
+  "sqlrules>=2,<3",
   "sqlalchemy>=2.0,<3",
 ]
 

sqlrules_postgresql-2.0.0/src/sqlrules_postgresql/__init__.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from sqlalchemy.dialects.postgresql import JSONB
+
+from sqlrules.backend import prepare_scalar
+from sqlrules.errors import CapabilityError
+from sqlrules.ir import CompilationContext, PreparedValue, RuleField
+from sqlrules.plugins import PLUGIN_API_VERSION
+from sqlrules.translators import TranslatorRegistry
+from sqlrules_postgresql.array import translate_array_contains, translate_array_overlap
+from sqlrules_postgresql.jsonb import translate_json_contains, translate_json_has_key
+from sqlrules_postgresql.pattern import translate_pattern
+from sqlrules_postgresql.range import translate_range_contains, translate_range_overlap
+
+__version__ = "2.0.0"
+
+
+class PostgresPlugin:
+    """Register PostgreSQL-specific constraint translators."""
+
+    name = "postgresql"
+    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",
+                "uuid",
+            ),
+            "safe_text_numeric_conversion": self.server_version is not None
+            and self.server_version >= (16, 0),
+            "safe_text_numeric_targets": (
+                ("int", "float", "decimal")
+                if self.server_version is not None and self.server_version >= (16, 0)
+                else ()
+            ),
+            "assumptions": ("PostgreSQL native column types provide logical type evidence.",),
+        }
+
+    def prepare_value(
+        self,
+        column: Any,
+        field: RuleField,
+        context: CompilationContext,
+    ) -> PreparedValue:
+        if (
+            field.python_type is dict
+            and any(
+                item.operator in {"json_contains", "json_has_key"} for item in field.constraints
+            )
+            and not isinstance(column.type, JSONB)
+        ):
+            raise CapabilityError(
+                self.name,
+                field.name,
+                "jsonb",
+                type(column.type).__name__,
+                "PostgreSQL JSON markers require a JSONB column; generic JSON does not provide "
+                "the containment and key operators used by SQLRules.",
+            )
+        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 (
+            ("json_contains", translate_json_contains),
+            ("json_has_key", translate_json_has_key),
+            ("array_contains", translate_array_contains),
+            ("array_overlap", translate_array_overlap),
+            ("range_contains", translate_range_contains),
+            ("range_overlap", translate_range_overlap),
+        ):
+            registry.register_constraint(operator, translator, on_conflict="replace")
+
+
+__all__ = [
+    "PostgresPlugin",
+    "__version__",
+    "translate_array_contains",
+    "translate_array_overlap",
+    "translate_json_contains",
+    "translate_json_has_key",
+    "translate_pattern",
+    "translate_range_contains",
+    "translate_range_overlap",
+]

{sqlrules_postgresql-1.0.1 → sqlrules_postgresql-2.0.0}/src/sqlrules_postgresql/jsonb.py

@@ -2,6 +2,7 @@ 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
@@ -22,4 +23,7 @@ def translate_json_has_key(
     context: CompilationContext,
 ) -> ColumnElement[bool]:
     """Translate ``json_has_key`` to JSONB ``?`` / ``has_key``."""
-    return cast(ColumnElement[bool], column.has_key(constraint.value))
+    return cast(
+        ColumnElement[bool],
+        (func.jsonb_typeof(column) == "object") & column.has_key(constraint.value),
+    )

sqlrules_postgresql-2.0.0/tests/test_postgres_plugin.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import re
+from typing import Annotated, Any
+
+from pydantic import Field
+from sqlalchemy import Column, MetaData, String, Table
+from sqlalchemy.dialects.postgresql import ARRAY, INT4RANGE, JSONB, dialect
+from sqlrules_postgresql import PostgresPlugin, __version__
+
+from sqlrules import ArrayContains, Compiler, JsonContains, RangeContains, RuleSchema
+from sqlrules.conformance import run_basic_conformance
+
+
+def test_version_and_plugin_conformance() -> None:
+    assert __version__ == "2.0.0"
+    run_basic_conformance(PostgresPlugin(server_version=(16, 0)), operator="pattern")
+
+
+def test_pattern_json_array_and_range_compile_with_v2_provider() -> None:
+    class Rules(RuleSchema):
+        name: Annotated[str, Field(pattern=re.compile(r"^a", re.I))]
+        meta: Annotated[dict[str, Any], JsonContains({"active": True})]
+        tags: Annotated[list[str], ArrayContains(["admin"])]
+        span: Annotated[int, RangeContains(5)]
+
+    table = Table(
+        "rows",
+        MetaData(),
+        Column("name", String),
+        Column("meta", JSONB),
+        Column("tags", ARRAY(String)),
+        Column("span", INT4RANGE),
+    )
+    compiled = Compiler(plugins=[PostgresPlugin(server_version=(16, 0))]).compile(Rules, table)
+    assert len(compiled.fields) == 4
+    assert compiled.fields[-1].logical_type == "range"
+    sql = str(compiled.predicate.compile(dialect=dialect()))
+    assert "~*" in sql
+    assert "@>" in sql
+    assert "@>" in sql
+
+
+def test_string_literal_requires_explicit_deterministic_collation() -> None:
+    from typing import Literal
+
+    from sqlrules import CapabilityError
+
+    class Rules(RuleSchema):
+        status: Literal["ready", "pending"]
+
+    table = Table("rows", MetaData(), Column("status", String))
+    try:
+        Compiler(plugins=[PostgresPlugin()]).compile(Rules, table)
+    except CapabilityError as exc:
+        assert "C or POSIX" in str(exc)
+    else:  # pragma: no cover - assertion is the capability contract
+        raise AssertionError("string literal compilation needs explicit collation")

sqlrules_postgresql-1.0.1/PKG-INFO

@@ -1,98 +0,0 @@
-Metadata-Version: 2.4
-Name: sqlrules-postgresql
-Version: 1.0.1
-Summary: PostgreSQL dialect plugin for SQLRules (regex, JSONB, ARRAY, range).
-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: postgresql,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-postgresql
-
-PostgreSQL dialect plugin for [SQLRules](https://github.com/eddiethedean/sqlrules).
-
-## Install
-
-```bash
-pip install sqlrules-postgresql
-```
-
-## Usage
-
-```python
-import re
-from typing import Annotated, Any
-
-from pydantic import BaseModel, Field
-from sqlalchemy import Column, MetaData, Table
-from sqlalchemy.dialects.postgresql import ARRAY, INT4RANGE, JSONB, TEXT
-
-from sqlrules import ArrayContains, Compiler, JsonContains, RangeContains
-from sqlrules_postgresql import PostgresPlugin
-
-class RowFilter(BaseModel):
-    name: Annotated[str, Field(pattern=re.compile(r"^a", re.I))]
-    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
-    tags: Annotated[list[str], ArrayContains(["admin"])]
-    span: Annotated[int, RangeContains(5)]
-
-table = Table(
-    "rows",
-    MetaData(),
-    Column("name", TEXT),
-    Column("meta", JSONB),
-    Column("tags", ARRAY(TEXT)),
-    Column("span", INT4RANGE),
-)
-
-compiler = Compiler(plugins=[PostgresPlugin()], dialect="postgresql")
-rules = compiler.compile(RowFilter, table)
-```
-
-## Operators
-
-| IR operator | SQLAlchemy / PostgreSQL |
-|---|---|
-| `pattern` | `~` or `~*` (when `PatternSpec.ignore_case`) |
-| `type_check` | Shape/type predicates from `TypeSpec` (see matrix below) |
-| `json_contains` | JSONB `contains` / `@>` |
-| `json_has_key` | JSONB `has_key` / `?` |
-| `array_contains` | array `contains` |
-| `array_overlap` | array `overlap` / `&&` |
-| `range_contains` | range `@>` |
-| `range_overlap` | range `&&` |
-
-### `type_check` matrix (approximate)
-
-Enable with `Compiler(..., emit_type_checks=True)`. Not full Pydantic
-parity — inexpressible pairs raise.
-
-| Python type | Lax | Strict |
-|---|---|---|
-| `int` | Integer column; String `~` digit pattern; numeric whole-number | Integer column only |
-| `bool` | unsupported (raise) | Boolean `IN (true, false)` |
-| `str` | String/Text `IS NOT NULL` | same |
-| `float` / `Decimal` | numeric column; String float-ish `~` | numeric column |
-| `date` / `datetime` / `time` / `UUID` | typed column or String format `~` | typed column |
-
-`Optional[T]` → `(column IS NULL) OR <predicate>`.
-
-## Security note
-
-`pattern` becomes a PostgreSQL regex (`~` / `~*`). Untrusted pattern strings
-can cause expensive engine-side evaluation (ReDoS-class cost). Prefer
-static/allowlisted patterns. See
-[SECURITY](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

sqlrules_postgresql-1.0.1/README.md

@@ -1,76 +0,0 @@
-# sqlrules-postgresql
-
-PostgreSQL dialect plugin for [SQLRules](https://github.com/eddiethedean/sqlrules).
-
-## Install
-
-```bash
-pip install sqlrules-postgresql
-```
-
-## Usage
-
-```python
-import re
-from typing import Annotated, Any
-
-from pydantic import BaseModel, Field
-from sqlalchemy import Column, MetaData, Table
-from sqlalchemy.dialects.postgresql import ARRAY, INT4RANGE, JSONB, TEXT
-
-from sqlrules import ArrayContains, Compiler, JsonContains, RangeContains
-from sqlrules_postgresql import PostgresPlugin
-
-class RowFilter(BaseModel):
-    name: Annotated[str, Field(pattern=re.compile(r"^a", re.I))]
-    meta: Annotated[dict[str, Any], JsonContains({"active": True})]
-    tags: Annotated[list[str], ArrayContains(["admin"])]
-    span: Annotated[int, RangeContains(5)]
-
-table = Table(
-    "rows",
-    MetaData(),
-    Column("name", TEXT),
-    Column("meta", JSONB),
-    Column("tags", ARRAY(TEXT)),
-    Column("span", INT4RANGE),
-)
-
-compiler = Compiler(plugins=[PostgresPlugin()], dialect="postgresql")
-rules = compiler.compile(RowFilter, table)
-```
-
-## Operators
-
-| IR operator | SQLAlchemy / PostgreSQL |
-|---|---|
-| `pattern` | `~` or `~*` (when `PatternSpec.ignore_case`) |
-| `type_check` | Shape/type predicates from `TypeSpec` (see matrix below) |
-| `json_contains` | JSONB `contains` / `@>` |
-| `json_has_key` | JSONB `has_key` / `?` |
-| `array_contains` | array `contains` |
-| `array_overlap` | array `overlap` / `&&` |
-| `range_contains` | range `@>` |
-| `range_overlap` | range `&&` |
-
-### `type_check` matrix (approximate)
-
-Enable with `Compiler(..., emit_type_checks=True)`. Not full Pydantic
-parity — inexpressible pairs raise.
-
-| Python type | Lax | Strict |
-|---|---|---|
-| `int` | Integer column; String `~` digit pattern; numeric whole-number | Integer column only |
-| `bool` | unsupported (raise) | Boolean `IN (true, false)` |
-| `str` | String/Text `IS NOT NULL` | same |
-| `float` / `Decimal` | numeric column; String float-ish `~` | numeric column |
-| `date` / `datetime` / `time` / `UUID` | typed column or String format `~` | typed column |
-
-`Optional[T]` → `(column IS NULL) OR <predicate>`.
-
-## Security note
-
-`pattern` becomes a PostgreSQL regex (`~` / `~*`). Untrusted pattern strings
-can cause expensive engine-side evaluation (ReDoS-class cost). Prefer
-static/allowlisted patterns. See
-[SECURITY](https://sqlrules.readthedocs.io/en/latest/SECURITY.html).

sqlrules_postgresql-1.0.1/src/sqlrules_postgresql/__init__.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from sqlrules.plugins import PLUGIN_API_VERSION
-from sqlrules.translators import TranslatorRegistry
-from sqlrules_postgresql.array import translate_array_contains, translate_array_overlap
-from sqlrules_postgresql.jsonb import translate_json_contains, translate_json_has_key
-from sqlrules_postgresql.pattern import translate_pattern
-from sqlrules_postgresql.range import translate_range_contains, translate_range_overlap
-from sqlrules_postgresql.type_check import translate_type_check
-
-__version__ = "1.0.1"
-
-
-class PostgresPlugin:
-    """Register PostgreSQL-specific constraint translators."""
-
-    name = "postgresql"
-    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),
-            ("array_contains", translate_array_contains),
-            ("array_overlap", translate_array_overlap),
-            ("range_contains", translate_range_contains),
-            ("range_overlap", translate_range_overlap),
-        ):
-            registry.register_constraint(operator, translator, on_conflict="replace")
-
-
-__all__ = [
-    "PostgresPlugin",
-    "__version__",
-    "translate_array_contains",
-    "translate_array_overlap",
-    "translate_json_contains",
-    "translate_json_has_key",
-    "translate_pattern",
-    "translate_range_contains",
-    "translate_range_overlap",
-    "translate_type_check",
-]

sqlrules_postgresql-1.0.1/src/sqlrules_postgresql/type_check.py

@@ -1,250 +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
-
-# Integer-like text (Pydantic lax int accepts digit strings).
-_INT_TEXT = r"^[+-]?(0|[1-9]\d*)$"
-# Float / Decimal-like text (simplified; not full Pydantic parity).
-_FLOAT_TEXT = r"^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$"
-# ISO-ish date / datetime / time (approximate).
-_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 _col_type(column: ColumnElement[Any]) -> TypeEngine[Any]:
-    return column.type
-
-
-def _is_type(column: ColumnElement[Any], *bases: type[TypeEngine[Any]]) -> bool:
-    col_type = _col_type(column)
-    if isinstance(col_type, NullType):
-        return False
-    return isinstance(col_type, bases)
-
-
-def _regex(column: ColumnElement[Any], pattern: str) -> ColumnElement[bool]:
-    return cast(ColumnElement[bool], column.op("~")(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):
-        # Typed integer column: every non-null value is already an int.
-        return cast(ColumnElement[bool], column.isnot(None))
-    if spec.strict:
-        _unsupported(
-            field,
-            spec,
-            "PostgreSQL strict int type_check requires an Integer column "
-            "(Pydantic strict mode rejects string/bool coercion).",
-        )
-    if _is_type(column, String):
-        return _regex(column, _INT_TEXT)
-    if _is_type(column, Float, Numeric):
-        # Whole numbers only (approximate Pydantic float→int when no fractional part).
-        return cast(ColumnElement[bool], column == column.cast(Integer).cast(Float))
-    _unsupported(
-        field,
-        spec,
-        "PostgreSQL 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):
-            return cast(ColumnElement[bool], column.in_((True, False)))
-        _unsupported(
-            field,
-            spec,
-            "PostgreSQL strict bool type_check requires a Boolean column.",
-        )
-    _unsupported(
-        field,
-        spec,
-        "PostgreSQL lax bool type_check is not supported (coercion set is not "
-        "deterministically expressible). Use Field(strict=True) or model_config "
-        "strict=True with a Boolean column.",
-    )
-    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,
-        "PostgreSQL str type_check requires a String/Text column "
-        "(Pydantic does not coerce other SQL types to str by default).",
-    )
-    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,
-            "PostgreSQL strict float/Decimal type_check requires a numeric column.",
-        )
-    if _is_type(column, String):
-        return _regex(column, _FLOAT_TEXT)
-    _unsupported(
-        field,
-        spec,
-        "PostgreSQL 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"PostgreSQL strict {type_name} type_check requires a typed {type_name} column.",
-        )
-    if _is_type(column, String):
-        return _regex(column, text_pattern)
-    type_name = spec.python_type.__name__
-    _unsupported(
-        field,
-        spec,
-        f"PostgreSQL {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]:
-    col_type = _col_type(column)
-    type_name = type(col_type).__name__.lower()
-    if "uuid" in type_name:
-        return cast(ColumnElement[bool], column.isnot(None))
-    if spec.strict:
-        _unsupported(
-            field,
-            spec,
-            "PostgreSQL strict UUID type_check requires a UUID column.",
-        )
-    if _is_type(column, String):
-        return _regex(column, _UUID_TEXT)
-    _unsupported(
-        field,
-        spec,
-        "PostgreSQL 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"PostgreSQL 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 a PostgreSQL shape/type predicate."""
-    del context  # dialect hint unused; plugin is already PostgreSQL-specific
-    spec = type_spec(constraint.value)
-    predicate = _build_predicate(column, spec, constraint.field)
-    return _wrap_none(column, predicate, allow_none=spec.allow_none)

sqlrules_postgresql-1.0.1/tests/test_postgres_plugin.py

@@ -1,213 +0,0 @@
-from __future__ import annotations
-
-import re
-from typing import Annotated, Any
-
-from pydantic import BaseModel, Field
-from sqlalchemy import Column, MetaData, String, Table
-from sqlalchemy.dialects import postgresql
-from sqlalchemy.dialects.postgresql import ARRAY, INT4RANGE, JSONB, TEXT
-from sqlrules_postgresql import PostgresPlugin, __version__
-
-from sqlrules import (
-    ArrayContains,
-    ArrayOverlap,
-    Compiler,
-    JsonContains,
-    JsonHasKey,
-    RangeContains,
-    RangeOverlap,
-)
-from sqlrules.conformance import run_basic_conformance
-
-
-def _sql(expr: object, *, literal_binds: bool = True) -> str:
-    return str(
-        expr.compile(  # type: ignore[union-attr]
-            dialect=postgresql.dialect(),
-            compile_kwargs={"literal_binds": literal_binds} if literal_binds else {},
-        )
-    )
-
-
-def test_version() -> None:
-    assert __version__ == "1.0.1"
-
-
-def test_conformance() -> None:
-    run_basic_conformance(PostgresPlugin(), operator="pattern")
-
-
-def test_pattern_compiles() -> None:
-    """PG ``~`` is substring search; Pydantic validates fullmatch — patterns often use ^/$."""
-
-    class Filter(BaseModel):
-        name: Annotated[str, Field(pattern=r"^A")]
-
-    table = Table("items", MetaData(), Column("name", String))
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        cache=False,
-    ).compile(Filter, table)
-    assert _sql(rules["name"][0]) == "items.name ~ '^A'"
-
-
-def test_pattern_ignore_case_uses_star() -> 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=[PostgresPlugin()],
-        dialect="postgresql",
-        cache=False,
-    ).compile(Filter, table)
-    assert _sql(rules["name"][0]) == "items.name ~* '^A'"
-
-
-def test_unanchored_pattern_emits_search_semantics() -> None:
-    """Unanchored patterns are emitted as-is (PG ``~`` search, not Pydantic fullmatch)."""
-
-    class Filter(BaseModel):
-        name: Annotated[str, Field(pattern=r"abc")]
-
-    table = Table("items", MetaData(), Column("name", String))
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        cache=False,
-    ).compile(Filter, table)
-    assert _sql(rules["name"][0]) == "items.name ~ 'abc'"
-
-
-def test_json_array_range_operators() -> None:
-    class Filter(BaseModel):
-        meta: Annotated[dict[str, Any], JsonContains({"active": True}), JsonHasKey("active")]
-        tags: Annotated[list[str], ArrayContains(["admin"]), ArrayOverlap(["x"])]
-        span: Annotated[int, RangeContains(5), RangeOverlap([1, 10])]
-
-    table = Table(
-        "rows",
-        MetaData(),
-        Column("meta", JSONB),
-        Column("tags", ARRAY(TEXT)),
-        Column("span", INT4RANGE),
-    )
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        cache=False,
-    ).compile(Filter, table)
-
-    # JSONB containment: operator + bound payload (literal_binds unsupported for JSONB).
-    contains = rules["meta"][0]
-    assert getattr(contains.operator, "opstring", None) == "@>"  # type: ignore[attr-defined]
-    assert contains.right.value == {"active": True}  # type: ignore[attr-defined]
-    assert "@>" in _sql(contains, literal_binds=False)
-
-    assert _sql(rules["meta"][1]) == "rows.meta ? 'active'"
-    assert _sql(rules["tags"][0]) == "rows.tags @> ARRAY['admin']"
-    assert _sql(rules["tags"][1]) == "rows.tags && ARRAY['x']"
-    assert _sql(rules["span"][0]) == "rows.span @> 5"
-    overlap = rules["span"][1]
-    assert getattr(overlap.operator, "opstring", None) == "&&"  # type: ignore[attr-defined]
-    assert overlap.right.value == [1, 10]  # type: ignore[attr-defined]
-
-
-def test_empty_json_contains_uses_containment() -> None:
-    class Filter(BaseModel):
-        meta: Annotated[dict[str, Any], JsonContains({})]
-
-    table = Table("rows", MetaData(), Column("meta", JSONB))
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        cache=False,
-    ).compile(Filter, table)
-    expr = rules["meta"][0]
-    assert getattr(expr.operator, "opstring", None) == "@>"  # type: ignore[attr-defined]
-    assert expr.right.value == {}  # type: ignore[attr-defined]
-    assert "@>" in _sql(expr, literal_binds=False)
-
-
-def test_type_check_int_and_str() -> None:
-    from sqlalchemy import Integer
-
-    class Filter(BaseModel):
-        age: int
-        name: str
-
-    table = Table(
-        "users",
-        MetaData(),
-        Column("age", Integer),
-        Column("name", String),
-    )
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        emit_type_checks=True,
-        cache=False,
-    ).compile(Filter, table)
-    assert _sql(rules["age"][0], literal_binds=False).upper().count("IS NOT NULL") == 1
-    assert "users.age" in _sql(rules["age"][0], literal_binds=False)
-    assert "users.name" in _sql(rules["name"][0], literal_binds=False)
-    assert "IS NOT NULL" in _sql(rules["name"][0], literal_binds=False).upper()
-
-
-def test_type_check_lax_int_on_string() -> None:
-    class Filter(BaseModel):
-        age: int
-
-    table = Table("rows", MetaData(), Column("age", String))
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        emit_type_checks=True,
-        cache=False,
-    ).compile(Filter, table)
-    compiled = _sql(rules["age"][0])
-    assert "rows.age" in compiled
-    assert "~" in compiled
-    # Lax int-on-text uses a digit regex, not a bare IS NOT NULL.
-    assert "IS NOT NULL" not in compiled.upper() or "~" in compiled
-
-
-def test_type_check_strict_bool() -> None:
-    from pydantic import ConfigDict
-    from sqlalchemy import Boolean
-
-    class Filter(BaseModel):
-        model_config = ConfigDict(strict=True)
-        active: bool
-
-    table = Table("rows", MetaData(), Column("active", Boolean))
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        emit_type_checks=True,
-        cache=False,
-    ).compile(Filter, table)
-    compiled = _sql(rules["active"][0])
-    assert "rows.active" in compiled
-    assert "IN" in compiled.upper()
-    assert "true" in compiled.lower() or "True" in compiled
-
-
-def test_type_check_optional_or_null() -> None:
-    from sqlalchemy import Integer
-
-    class Filter(BaseModel):
-        age: int | None = None
-
-    table = Table("rows", MetaData(), Column("age", Integer))
-    rules = Compiler(
-        plugins=[PostgresPlugin()],
-        dialect="postgresql",
-        emit_type_checks=True,
-        cache=False,
-    ).compile(Filter, table)
-    compiled = _sql(rules["age"][0], literal_binds=False).upper()
-    assert "IS NULL" in compiled
-    assert "IS NOT NULL" in compiled