sqlrules 0.3.0__tar.gz → 0.4.0__tar.gz

{sqlrules-0.3.0 → sqlrules-0.4.0}/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0/).
 
+## [0.4.0] - 2026-07-10
+
+### Added
+
+- `ConstraintMarker` protocol and shared markers in `sqlrules.markers`:
+  `JsonContains`, `JsonHasKey`, `ArrayContains`, `ArrayOverlap`,
+  `RangeContains`, `RangeOverlap`, `FullTextMatch`
+- `PatternSpec` IR value for `pattern` (preserves `ignore_case` from
+  `re.Pattern` flags); `pattern_text()` helper for plugins
+- `list` / `dict` annotations for marker-driven fields (portable
+  constraints on containers still raise)
+- Expanded dialect plugins:
+  - `sqlrules-postgresql` — `~` / `~*`, JSONB, ARRAY, range operators
+  - `sqlrules-sqlite` — `register_regexp()`, flag-aware REGEXP, JSON helpers
+  - `sqlrules-mysql` — REGEXP, JSON, `fulltext_match`
+  - `sqlrules-mssql` — JSON helpers, `LEN` overrides for length constraints
+- Conformance helpers accept optional `model` / `table` / `field` for
+  non-`pattern` operators
+
+### Changed
+
+- Package version bumped to 0.4.0
+- Official plugin packages depend on `sqlrules>=0.4,<0.5`
+
 ## [0.3.0] - 2026-07-10
 
 ### Added
@@ -108,6 +132,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Docs clarify that `on_unsupported` does not soften unsupported types;
   plugin / two-phase compile designs are marked as future
 
+[0.4.0]: https://github.com/eddiethedean/sqlrules/releases/tag/v0.4.0
 [0.3.0]: https://github.com/eddiethedean/sqlrules/releases/tag/v0.3.0
 [0.2.0]: https://github.com/eddiethedean/sqlrules/releases/tag/v0.2.0
 [0.1.0]: https://github.com/eddiethedean/sqlrules/releases/tag/v0.1.0

{sqlrules-0.3.0 → sqlrules-0.4.0}/CONTRIBUTING.md

@@ -16,7 +16,8 @@ Thanks for helping improve SQLRules.
 python -m venv .venv
 source .venv/bin/activate
 pip install -e ".[dev]"
-pip install -e packages/sqlrules-postgresql -e packages/sqlrules-sqlite
+pip install -e packages/sqlrules-postgresql -e packages/sqlrules-sqlite \
+  -e packages/sqlrules-mysql -e packages/sqlrules-mssql
 pre-commit install
 ```
 
@@ -26,10 +27,13 @@ pre-commit install
 ruff check .
 ruff format --check .
 mypy src/sqlrules
-pytest tests packages/sqlrules-postgresql/tests packages/sqlrules-sqlite/tests
+pytest tests packages/sqlrules-postgresql/tests packages/sqlrules-sqlite/tests \
+  packages/sqlrules-mysql/tests packages/sqlrules-mssql/tests
 python -m build && twine check dist/*
 python -m build packages/sqlrules-postgresql --outdir dist-plugins
 python -m build packages/sqlrules-sqlite --outdir dist-plugins
+python -m build packages/sqlrules-mysql --outdir dist-plugins
+python -m build packages/sqlrules-mssql --outdir dist-plugins
 twine check dist-plugins/*
 ```
 
@@ -42,7 +46,7 @@ wheel imports cleanly.
 - Prefer `register_constraint(..., on_conflict=...)`.
 - Run `sqlrules.conformance.run_basic_conformance(plugin)`.
 - Official dialect packages live under `packages/` and should track the
-  plugin API major (`sqlrules>=0.3,<0.4` while `PLUGIN_API_VERSION == "1"`).
+  core minor (`sqlrules>=0.4,<0.5` while `PLUGIN_API_VERSION == "1"`).
 
 ## Pull requests
 
@@ -58,11 +62,11 @@ Releases are published to PyPI by pushing a version tag. Before tagging:
 2. Run the full check suite (`ruff`, `mypy`, `pytest`).
 3. Ensure CI is green on `main`.
 
-Then create and push the tag (example for 0.3.0):
+Then create and push the tag (example for 0.4.0):
 
 ```bash
-git tag -a v0.3.0 -m "sqlrules 0.3.0"
-git push origin v0.3.0
+git tag -a v0.4.0 -m "sqlrules 0.4.0"
+git push origin v0.4.0
 ```
 
 The [release workflow](.github/workflows/release.yml) runs CI, verifies the
@@ -71,10 +75,12 @@ publishes **core** `sqlrules` with `PYPI_API_TOKEN`.
 
 Dialect plugin packages under `packages/` are versioned independently and
 are **not** published by the core release workflow. Publish them separately
-after core `0.3.0` is on PyPI (they depend on `sqlrules>=0.3,<0.4`):
+after core `0.4.0` is on PyPI (they depend on `sqlrules>=0.4,<0.5`):
 
 ```bash
-python -m build packages/sqlrules-postgresql
-python -m build packages/sqlrules-sqlite
-twine upload dist-plugins/*   # after building with --outdir dist-plugins
+python -m build packages/sqlrules-postgresql --outdir dist-plugins
+python -m build packages/sqlrules-sqlite --outdir dist-plugins
+python -m build packages/sqlrules-mysql --outdir dist-plugins
+python -m build packages/sqlrules-mssql --outdir dist-plugins
+twine upload dist-plugins/*
 ```

{sqlrules-0.3.0 → sqlrules-0.4.0}/PKG-INFO

@@ -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 → sqlrules-0.4.0}/README.md

@@ -44,19 +44,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 |
 |---|---|
@@ -66,9 +74,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
@@ -107,8 +117,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 → sqlrules-0.4.0}/docs/API.md

@@ -90,6 +90,7 @@ instances.
 
 ```python
 from sqlrules import PLUGIN_API_VERSION, Compiler
+from sqlrules.constraints import pattern_text
 
 class MyPlugin:
     name = "my-plugin"
@@ -98,15 +99,16 @@ class MyPlugin:
     def register(self, registry):
         registry.register_constraint(
             "pattern",
-            lambda c, col, ctx: col.op("~")(c.value),
+            lambda c, col, ctx: col.op("~")(pattern_text(c.value)[0]),
             on_conflict="replace",
         )
 
 compiler = Compiler(plugins=[MyPlugin()])
 ```
 
-See [PLUGIN_SYSTEM.md](PLUGIN_SYSTEM.md). Conformance helpers live in
-`sqlrules.conformance`.
+Dialect markers (`JsonContains`, `ArrayContains`, …) are extracted into IR
+and translated by official dialect plugins. See [PLUGIN_SYSTEM.md](PLUGIN_SYSTEM.md).
+Conformance helpers live in `sqlrules.conformance`.
 
 ## Other exports
 
@@ -116,7 +118,9 @@ Also exported for advanced use and typing:
 - `PLUGIN_API_VERSION`, `SQLRulesPlugin`
 - `SQLRulesWarning`
 - `CompilationContext`, `Constraint`, `FieldDescriptor`, `FieldIR`, `ModelIR`,
-  `Diagnostic` (IR helpers)
+  `Diagnostic`, `PatternSpec`
+- Markers: `ConstraintMarker`, `JsonContains`, `JsonHasKey`, `ArrayContains`,
+  `ArrayOverlap`, `RangeContains`, `RangeOverlap`, `FullTextMatch`
 
 `DiagnosticsCollector` and `ModelIRCache` are internal (import from
 `sqlrules.ir` / `sqlrules.cache` only if you accept instability).

sqlrules-0.4.0/docs/CONSTRAINTS.md

@@ -0,0 +1,55 @@
+# Supported Constraint Mapping
+
+| Constraint | SQLAlchemy expression |
+|---|---|
+| `gt` | `column > value` |
+| `ge` | `column >= value` |
+| `lt` | `column < value` |
+| `le` | `column <= value` |
+| `min_length` | `func.length(column) >= value` |
+| `max_length` | `func.length(column) <= value` |
+| `multiple_of` | `column % value == 0` |
+| `Literal[...]` | `column.in_(...)` |
+| `Enum` | `column.in_(member values)` |
+| `pattern` | IR (`PatternSpec`); translators via plugins / custom registry |
+
+## Dialect markers (`sqlrules.markers`)
+
+| Marker | IR operator | Typical plugin translation |
+|---|---|---|
+| `JsonContains` | `json_contains` | JSONB / JSON containment |
+| `JsonHasKey` | `json_has_key` | JSON key existence |
+| `ArrayContains` | `array_contains` | PostgreSQL array containment |
+| `ArrayOverlap` | `array_overlap` | PostgreSQL array overlap |
+| `RangeContains` | `range_contains` | PostgreSQL range `@>` |
+| `RangeOverlap` | `range_overlap` | PostgreSQL range `&&` |
+| `FullTextMatch` | `fulltext_match` | MySQL `MATCH ... AGAINST` |
+
+Accepted input forms for portable constraints include `Field(...)`,
+`annotated_types` primitives, `Interval`, `Len`, `conint`/`constr`, and
+`StringConstraints` (length attributes; `pattern` becomes `PatternSpec` IR).
+
+Constraints without a deterministic SQL equivalent are rejected by default.
+See [TYPE_SUPPORT.md](TYPE_SUPPORT.md) and [ERRORS.md](ERRORS.md).
+
+To translate `pattern` or markers, use a dialect plugin:
+
+```python
+from sqlrules import Compiler, JsonContains
+from sqlrules_postgresql import PostgresPlugin
+
+compiler = Compiler(plugins=[PostgresPlugin()], dialect="postgresql")
+```
+
+```python
+from sqlrules.constraints import pattern_text
+from sqlrules.translators import default_registry
+
+registry = default_registry()
+registry.register_constraint(
+    "pattern",
+    lambda c, col, ctx: col.op("~")(pattern_text(c.value)[0]),
+    on_conflict="replace",
+)
+compiler = sqlrules.Compiler(registry=registry)
+```

{sqlrules-0.3.0 → sqlrules-0.4.0}/docs/DIALECT_SUPPORT.md

@@ -29,18 +29,18 @@ compiler deterministic.
 
 ------------------------------------------------------------------------
 
-# Planned Dialects
+# Dialects
 
 Core emits portable SQLAlchemy Core expressions. The table below describes
 **intended** dialect posture, not a certified multi-backend test matrix.
 
   Dialect             Status        Notes
   ------------ -------------------- --------------------------------
-  SQLite             Core + plugin  `sqlrules-sqlite` adds `pattern` (REGEXP)
-  PostgreSQL         Core + plugin  `sqlrules-postgresql` adds `pattern` (`~`)
-  MySQL              Core (planned) Enhanced features via future plugin
-  MariaDB            Core (planned) Follows MySQL where practical
-  SQL Server         Core (planned) Enhanced features via future plugin
+  SQLite             Core + plugin  `sqlrules-sqlite` — REGEXP + JSON
+  PostgreSQL         Core + plugin  `sqlrules-postgresql` — regex, JSONB, ARRAY, range
+  MySQL              Core + plugin  `sqlrules-mysql` — REGEXP, JSON, full-text
+  MariaDB            Core + plugin  Follows MySQL plugin where practical
+  SQL Server         Core + plugin  `sqlrules-mssql` — JSON + `LEN`
   Oracle             Planned        Core support after 1.0
 
 ------------------------------------------------------------------------
@@ -61,20 +61,33 @@ These should compile identically across supported databases:
 
 ------------------------------------------------------------------------
 
-# PostgreSQL
+# Shared dialect markers
 
-Package: `sqlrules-postgresql`
+Dialect-oriented operators are expressed with `sqlrules.markers` and
+extracted into IR. Core does not translate them; plugins register
+translators for the stable operator names:
+
+-   `JsonContains` → `json_contains`
+-   `JsonHasKey` → `json_has_key`
+-   `ArrayContains` → `array_contains`
+-   `ArrayOverlap` → `array_overlap`
+-   `RangeContains` → `range_contains`
+-   `RangeOverlap` → `range_overlap`
+-   `FullTextMatch` → `fulltext_match`
 
-0.3 enhancement:
+`list` / `dict` field annotations are allowed for marker-driven fields.
+Portable constraints on containers still raise.
+
+------------------------------------------------------------------------
 
--   Native regular expressions via `pattern` → `column ~ value`
+# PostgreSQL
 
-Potential later enhancements (0.4+):
+Package: `sqlrules-postgresql`
 
--   ARRAY operators
--   JSONB operators
--   Range types
--   Full-text search
+-   `pattern` → `~` or `~*` (`PatternSpec.ignore_case`)
+-   JSONB containment / key checks
+-   ARRAY contains / overlap
+-   range `@>` / `&&`
 
 ------------------------------------------------------------------------
 
@@ -82,37 +95,29 @@ Potential later enhancements (0.4+):
 
 Package: `sqlrules-sqlite`
 
-Goals:
-
--   Reliable test platform
--   Portable numeric comparisons
--   Portable string-length operations
--   `pattern` via `REGEXP` (application must enable REGEXP on the connection)
-
-Limitations:
-
--   REGEXP requires an extension / `create_function`
--   Limited advanced JSON functionality
+-   `pattern` via `REGEXP` — call `register_regexp(connection)`
+-   Case-insensitive patterns use a `(?i)` prefix understood by the helper
+-   JSON helpers via JSON1 `json_extract` / `json_type`
 
 ------------------------------------------------------------------------
 
 # MySQL / MariaDB
 
-Potential enhancements:
+Package: `sqlrules-mysql`
 
--   Full-text search
--   JSON operators
--   Generated column optimizations
+-   `pattern` → `REGEXP`
+-   JSON operators (`JSON_CONTAINS`, `JSON_CONTAINS_PATH`)
+-   `fulltext_match` → `MATCH ... AGAINST` (requires FULLTEXT index)
 
 ------------------------------------------------------------------------
 
 # SQL Server
 
-Potential enhancements:
+Package: `sqlrules-mssql`
 
--   Specialized string functions
--   JSON functions
--   Spatial operators
+-   `min_length` / `max_length` → `LEN`
+-   JSON helpers via `JSON_VALUE` / `JSON_QUERY`
+-   `pattern` is not registered (no deterministic portable regex)
 
 ------------------------------------------------------------------------
 
@@ -145,36 +150,16 @@ If no override exists, the portable translator is used.
 
 ------------------------------------------------------------------------
 
-# Example
-
-Portable:
-
-``` python
-func.length(users.c.name) >= 3
-```
-
-PostgreSQL plugin:
-
-``` python
-users.c.name.op("~")(pattern)
-```
-
-Both originate from the same IR.
-
-------------------------------------------------------------------------
-
 # Plugin Packages
 
-Recommended official plugins:
+Official plugins:
 
 -   sqlrules-postgresql
 -   sqlrules-sqlite
 -   sqlrules-mysql
 -   sqlrules-mssql
--   sqlrules-oracle
 
-Each package should register only the translators relevant to its
-backend.
+Each package registers only the translators relevant to its backend.
 
 ------------------------------------------------------------------------
 
@@ -184,7 +169,6 @@ Every supported dialect should include:
 
 -   Unit tests
 -   SQL compilation tests
--   Integration tests
 -   Regression tests
 
 The same Pydantic model should produce equivalent logical behavior

{sqlrules-0.3.0 → sqlrules-0.4.0}/docs/MILESTONES.md

@@ -114,7 +114,7 @@ Official plugin packages begin:
 
 ------------------------------------------------------------------------
 
-# 0.4.0 --- Dialect Enhancements
+# 0.4.0 --- Dialect Enhancements ✅
 
 ## Goals
 
@@ -122,14 +122,14 @@ Provide optimized translations for major databases.
 
 ### PostgreSQL
 
--   regex
+-   regex (`~` / `~*`)
 -   JSONB
 -   ARRAY
 -   range operators
 
 ### SQLite
 
--   REGEXP integration
+-   REGEXP integration (`register_regexp`)
 -   JSON helpers
 
 ### MySQL / MariaDB
@@ -140,7 +140,13 @@ Provide optimized translations for major databases.
 ### SQL Server
 
 -   JSON support
--   string optimizations
+-   string optimizations (`LEN`)
+
+### Core
+
+-   `ConstraintMarker` + `sqlrules.markers`
+-   `PatternSpec` for pattern IR
+-   `list` / `dict` type support for marker fields
 
 ------------------------------------------------------------------------
 

{sqlrules-0.3.0 → sqlrules-0.4.0}/docs/PLUGIN_SYSTEM.md

@@ -51,6 +51,7 @@ A plugin is a Python object that exposes `name`, `api_version`, and
 
 ``` python
 from sqlrules import PLUGIN_API_VERSION
+from sqlrules.constraints import pattern_text
 from sqlrules.translators import TranslatorRegistry
 
 class CompanyPlugin:
@@ -60,12 +61,21 @@ class CompanyPlugin:
     def register(self, registry: TranslatorRegistry) -> None:
         registry.register_constraint(
             "pattern",
-            lambda c, col, ctx: col.op("~")(c.value),
+            lambda c, col, ctx: col.op("~")(pattern_text(c.value)[0]),
             on_conflict="replace",
         )
 ```
 
-`api_version` must equal `sqlrules.PLUGIN_API_VERSION` (`"1"` in 0.3).
+`api_version` must equal `sqlrules.PLUGIN_API_VERSION` (`"1"` in 0.4).
+
+------------------------------------------------------------------------
+
+# Markers
+
+Dialect-oriented constraints use `sqlrules.markers` (for example
+`JsonContains`, `ArrayContains`). Markers implement the
+`ConstraintMarker` protocol (`operator`, `value`) and are extracted into
+IR. Plugins register translators for those operator names.
 
 ------------------------------------------------------------------------
 
@@ -91,7 +101,7 @@ Invalid translators raise `InvalidTranslatorError`. Duplicate operators
 raise `RegistryError` unless `on_conflict` / `replace` allows otherwise.
 
 `register_type`, `register_dialect`, and `register_compiler_pass` are
-not implemented in 0.3 (reserved).
+not implemented (reserved).
 
 ------------------------------------------------------------------------
 
@@ -121,14 +131,12 @@ caller-owned registries are never mutated.
 
 # Dialect Plugins
 
-Official starter packages (same monorepo under `packages/`):
-
-- `sqlrules-postgresql` — `pattern` → `column ~ value`
-- `sqlrules-sqlite` — `pattern` → `column REGEXP value` (app must enable REGEXP)
+Official packages (monorepo under `packages/`):
 
-Dialect plugins override or supplement built-in translators while
-preserving the same IR. JSONB, ARRAY, and other enhancements are planned
-for 0.4.
+- `sqlrules-postgresql` — regex, JSONB, ARRAY, range
+- `sqlrules-sqlite` — REGEXP helper + JSON
+- `sqlrules-mysql` — REGEXP, JSON, full-text
+- `sqlrules-mssql` — JSON + `LEN` length overrides
 
 ------------------------------------------------------------------------
 
@@ -168,7 +176,8 @@ run_basic_conformance(PostgresPlugin(), operator="pattern")
 ```
 
 Helpers also cover API version checks, builtin preservation, and
-deterministic translation.
+deterministic translation. Pass `model=` / `table=` / `field=` when
+conformance-checking non-`pattern` operators.
 
 ------------------------------------------------------------------------
 
@@ -185,7 +194,7 @@ The plugin system does not support:
 
 - Runtime SQL execution
 - Database connections
-- Automatic package downloads / entry-point discovery (0.3)
+- Automatic package downloads / entry-point discovery
 - Dynamic code generation
 - Compiler pass plugins (future)
 

{sqlrules-0.3.0 → sqlrules-0.4.0}/docs/ROADMAP.md

@@ -28,11 +28,12 @@
 - Versioned plugin API (`PLUGIN_API_VERSION`)
 - Diagnostic codes
 
-## 0.4 — Dialect Enhancements
+## 0.4 — Dialect Enhancements ✅
 
 - PostgreSQL regex polish, JSONB, ARRAY, range operators
 - SQLite REGEXP integration helpers
 - MySQL / MariaDB / SQL Server enhancements
+- Shared `ConstraintMarker` / `sqlrules.markers` API
 
 ## 1.0 — Stable
 

{sqlrules-0.3.0 → sqlrules-0.4.0}/docs/SPEC.md

@@ -16,7 +16,7 @@ Ordering is deterministic and follows model field declaration order.
 Within a field, expressions follow constraint extraction order.
 Fields that produce no expressions are omitted from the dictionary.
 
-## Supported constraints (v0.3)
+## Supported constraints (v0.4)
 
 - `gt`
 - `ge`
@@ -28,17 +28,20 @@ Fields that produce no expressions are omitted from the dictionary.
 - `Literal`
 - `Enum`
 
-`pattern` is extracted into IR but has no portable core translator. It raises
-by default; use `on_unsupported="warn"` / `"ignore"`, register a custom
-translator, or install a dialect plugin (`sqlrules-postgresql`,
-`sqlrules-sqlite`).
+`pattern` is extracted into IR as `PatternSpec` but has no portable core
+translator. It raises by default; use `on_unsupported="warn"` / `"ignore"`,
+register a custom translator, or install a dialect plugin.
 
-## Supported types (v0.2)
+Dialect markers (`JsonContains`, `ArrayContains`, `RangeContains`,
+`FullTextMatch`, …) are extracted into IR and require a dialect plugin.
+
+## Supported types (v0.4)
 
 - `bool`, `int`, `float`, `Decimal`, `str`
 - `date`, `datetime`, `time`
 - `UUID` (Literal / Enum only)
 - `Literal[...]`, `Enum`
+- `list` / `dict` (marker-driven fields only)
 
 ## Unsupported constraints