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

sqlrules_postgresql/__init__.py

@@ -1,14 +1,21 @@
 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
-from sqlrules_postgresql.type_check import translate_type_check
 
-__version__ = "1.0.1"
+__version__ = "2.0.0"
 
 
 class PostgresPlugin:
@@ -17,17 +24,63 @@ class PostgresPlugin:
     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",
         )
-        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),
@@ -49,5 +102,4 @@ __all__ = [
     "translate_pattern",
     "translate_range_contains",
     "translate_range_overlap",
-    "translate_type_check",
 ]

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+sqlrules_postgresql/__init__.py,sha256=PFGK_zUbwUWHt-PE-3njuzw0C5zZIWTZBTf7zXycM-w,3684
+sqlrules_postgresql/array.py,sha256=Kzin-DQRwidhVsL6hL8c04ejSjEfGjcMZewjSHmH_3s,764
+sqlrules_postgresql/jsonb.py,sha256=KYl8AyZAdGqjFT7hjeWm4yLpJXbKuMYLDPomZJuMVuc,843
+sqlrules_postgresql/pattern.py,sha256=swLYUSmd0sgW-XSYunYBBnoT2QpwkzDsXfuL38cgXqU,599
+sqlrules_postgresql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlrules_postgresql/range.py,sha256=WBvd5yHpkP2UNmU_TxCNdHj-HdTMYVPO_PztqWj6TUs,774
+sqlrules_postgresql-2.0.0.dist-info/METADATA,sha256=Fip_8BMPGyf6l-KlxGsxkyZhsnajXqCa1WQRX3kFUxg,2657
+sqlrules_postgresql-2.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+sqlrules_postgresql-2.0.0.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
+sqlrules_postgresql-2.0.0.dist-info/RECORD,,

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

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

sqlrules_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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -1,11 +0,0 @@
-sqlrules_postgresql/__init__.py,sha256=Axgd7Vsg1PKCIMCi4iU9SaEtK3sePkM14v9dOVqLOL4,1805
-sqlrules_postgresql/array.py,sha256=Kzin-DQRwidhVsL6hL8c04ejSjEfGjcMZewjSHmH_3s,764
-sqlrules_postgresql/jsonb.py,sha256=SKuAD5S8RZZ27-ntbXSi1jVJ3b7Yw7K956DOUYFYUvU,750
-sqlrules_postgresql/pattern.py,sha256=swLYUSmd0sgW-XSYunYBBnoT2QpwkzDsXfuL38cgXqU,599
-sqlrules_postgresql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlrules_postgresql/range.py,sha256=WBvd5yHpkP2UNmU_TxCNdHj-HdTMYVPO_PztqWj6TUs,774
-sqlrules_postgresql/type_check.py,sha256=q7AA5hMiVLgDmdhfWt64123sBHcGG3ntkmprf-w58s8,7927
-sqlrules_postgresql-1.0.1.dist-info/METADATA,sha256=ILbicMQXIGVkPQ3gtYYNgLJvdf4FnvRTmlrMSJLHMeI,3232
-sqlrules_postgresql-1.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-sqlrules_postgresql-1.0.1.dist-info/licenses/LICENSE,sha256=cLMlkCH6RhjWAkXBWR7LazV98TOG0WkPtCKB5zqqkAs,1078
-sqlrules_postgresql-1.0.1.dist-info/RECORD,,