sqlrules-postgresql 1.0.1__tar.gz

sqlrules_postgresql-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_postgresql-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_postgresql-1.0.1/PKG-INFO

@@ -0,0 +1,98 @@
+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

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

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sqlrules-postgresql"
+version = "1.0.1"
+description = "PostgreSQL dialect plugin for SQLRules (regex, JSONB, ARRAY, range)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "SQLRules Contributors" }]
+keywords = ["sqlrules", "postgresql", "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_postgresql"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

sqlrules_postgresql-1.0.1/src/sqlrules_postgresql/__init__.py

@@ -0,0 +1,53 @@
+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/array.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def translate_array_contains(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``array_contains`` to PostgreSQL array containment."""
+    return cast(ColumnElement[bool], column.contains(constraint.value))
+
+
+def translate_array_overlap(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``array_overlap`` to PostgreSQL array overlap (``&&``)."""
+    return cast(ColumnElement[bool], column.overlap(constraint.value))

sqlrules_postgresql-1.0.1/src/sqlrules_postgresql/jsonb.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def translate_json_contains(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``json_contains`` to JSONB containment (``@>``)."""
+    return cast(ColumnElement[bool], column.contains(constraint.value))
+
+
+def translate_json_has_key(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``json_has_key`` to JSONB ``?`` / ``has_key``."""
+    return cast(ColumnElement[bool], column.has_key(constraint.value))

sqlrules_postgresql-1.0.1/src/sqlrules_postgresql/pattern.py

@@ -0,0 +1,19 @@
+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 PostgreSQL ``~`` or case-insensitive ``~*``."""
+    pattern, ignore_case = pattern_text(constraint.value)
+    op = "~*" if ignore_case else "~"
+    return cast(ColumnElement[bool], column.op(op)(pattern))

sqlrules_postgresql-1.0.1/src/sqlrules_postgresql/range.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def translate_range_contains(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``range_contains`` to PostgreSQL range containment (``@>``)."""
+    return cast(ColumnElement[bool], column.op("@>")(constraint.value))
+
+
+def translate_range_overlap(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``range_overlap`` to PostgreSQL range overlap (``&&``)."""
+    return cast(ColumnElement[bool], column.op("&&")(constraint.value))

sqlrules_postgresql-1.0.1/src/sqlrules_postgresql/type_check.py

@@ -0,0 +1,250 @@
+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

@@ -0,0 +1,213 @@
+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