sqlrules-mssql 1.0.0__tar.gz

sqlrules_mssql-1.0.0/.gitignore

@@ -0,0 +1,21 @@
+.venv/
+venv/
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+dist/
+dist-plugins/
+build/
+*.egg-info/
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.swo
+docs/_build/

sqlrules_mssql-1.0.0/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_mssql-1.0.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: sqlrules-mssql
+Version: 1.0.0
+Summary: SQL Server dialect plugin for SQLRules (JSON and LEN string ops).
+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: mssql,pydantic,sqlalchemy,sqlrules,sqlserver
+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-mssql
+
+SQL Server dialect plugin for [SQLRules](https://github.com/eddiethedean/sqlrules).
+
+## Install
+
+```bash
+pip install sqlrules-mssql
+```
+
+## Usage
+
+```python
+from typing import Annotated, Any
+
+from pydantic import BaseModel, Field
+
+from sqlrules import Compiler, JsonContains, JsonHasKey
+from sqlrules_mssql import MssqlPlugin
+
+class RowFilter(BaseModel):
+    name: Annotated[str, Field(min_length=2, max_length=40)]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True}), JsonHasKey("active")]
+
+compiler = Compiler(plugins=[MssqlPlugin()], dialect="mssql")
+```
+
+## Operators
+
+| IR operator | Notes |
+|---|---|
+| `min_length` / `max_length` | `LEN(column)` instead of portable `length()` |
+| `type_check` | Limited shape checks (typed columns; LIKE for some String forms) |
+| `json_contains` | Shallow `JSON_VALUE` / `JSON_QUERY` checks |
+| `json_has_key` | `JSON_VALUE` / `JSON_QUERY` IS NOT NULL |
+
+`pattern` is intentionally not registered — prefer a custom translator over
+guessing LIKE semantics.

sqlrules_mssql-1.0.0/README.md

@@ -0,0 +1,38 @@
+# sqlrules-mssql
+
+SQL Server dialect plugin for [SQLRules](https://github.com/eddiethedean/sqlrules).
+
+## Install
+
+```bash
+pip install sqlrules-mssql
+```
+
+## Usage
+
+```python
+from typing import Annotated, Any
+
+from pydantic import BaseModel, Field
+
+from sqlrules import Compiler, JsonContains, JsonHasKey
+from sqlrules_mssql import MssqlPlugin
+
+class RowFilter(BaseModel):
+    name: Annotated[str, Field(min_length=2, max_length=40)]
+    meta: Annotated[dict[str, Any], JsonContains({"active": True}), JsonHasKey("active")]
+
+compiler = Compiler(plugins=[MssqlPlugin()], dialect="mssql")
+```
+
+## Operators
+
+| IR operator | Notes |
+|---|---|
+| `min_length` / `max_length` | `LEN(column)` instead of portable `length()` |
+| `type_check` | Limited shape checks (typed columns; LIKE for some String forms) |
+| `json_contains` | Shallow `JSON_VALUE` / `JSON_QUERY` checks |
+| `json_has_key` | `JSON_VALUE` / `JSON_QUERY` IS NOT NULL |
+
+`pattern` is intentionally not registered — prefer a custom translator over
+guessing LIKE semantics.

sqlrules_mssql-1.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sqlrules-mssql"
+version = "1.0.0"
+description = "SQL Server dialect plugin for SQLRules (JSON and LEN string ops)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "SQLRules Contributors" }]
+keywords = ["sqlrules", "mssql", "sqlserver", "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_mssql"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

sqlrules_mssql-1.0.0/src/sqlrules_mssql/__init__.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from sqlrules.plugins import PLUGIN_API_VERSION
+from sqlrules.translators import TranslatorRegistry
+from sqlrules_mssql.json import translate_json_contains, translate_json_has_key
+from sqlrules_mssql.length import translate_max_length, translate_min_length
+from sqlrules_mssql.type_check import translate_type_check
+
+__version__ = "1.0.0"
+
+
+class MssqlPlugin:
+    """Register SQL Server constraint translators.
+
+    Does not register ``pattern`` — SQL Server has no portable regex operator
+    that SQLRules can emit deterministically. Provide a custom translator if
+    needed. ``type_check`` is registered with a limited approximation matrix.
+    """
+
+    name = "mssql"
+    api_version = PLUGIN_API_VERSION
+
+    def register(self, registry: TranslatorRegistry) -> None:
+        registry.register_constraint(
+            "min_length",
+            translate_min_length,
+            on_conflict="replace",
+        )
+        registry.register_constraint(
+            "max_length",
+            translate_max_length,
+            on_conflict="replace",
+        )
+        registry.register_constraint(
+            "type_check",
+            translate_type_check,
+            on_conflict="replace",
+        )
+        registry.register_constraint(
+            "json_contains",
+            translate_json_contains,
+            on_conflict="replace",
+        )
+        registry.register_constraint(
+            "json_has_key",
+            translate_json_has_key,
+            on_conflict="replace",
+        )
+
+
+__all__ = [
+    "MssqlPlugin",
+    "__version__",
+    "translate_json_contains",
+    "translate_json_has_key",
+    "translate_max_length",
+    "translate_min_length",
+    "translate_type_check",
+]

sqlrules_mssql-1.0.0/src/sqlrules_mssql/json.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+from typing import Any, cast
+
+from sqlalchemy import String, exists, func, literal, select, type_coerce
+from sqlalchemy import cast as sa_cast
+from sqlalchemy import column as sa_column
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def _json_path_for_key(key: Any) -> str:
+    """Build a JSONPath for a single object key (never a full-path escape hatch)."""
+    text = str(key)
+    # SQL Server JSON path quotes use doubled double-quotes inside the name.
+    escaped = text.replace('"', '""')
+    return f'$."{escaped}"'
+
+
+def _compact_dumps(value: Any) -> str:
+    return json.dumps(value, separators=(",", ":"))
+
+
+def _openjson_key_exists(
+    column: ColumnElement[Any],
+    key: str,
+    *,
+    json_type: str | None = None,
+) -> ColumnElement[bool]:
+    """True when OPENJSON lists ``key`` (optionally with a specific JSON type)."""
+    oj = (
+        func.openjson(column)
+        .table_valued(
+            sa_column("key", String),
+            sa_column("value", String),
+            sa_column("type", String),
+        )
+        .render_derived(name="oj", with_types=True)
+        .alias("oj")
+    )
+    predicate = oj.c.key == key
+    if json_type is not None:
+        predicate = predicate & (oj.c.type == json_type)
+    return cast(ColumnElement[bool], exists(select(1).select_from(oj).where(predicate)))
+
+
+def translate_json_contains(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``json_contains`` using SQL Server JSON functions.
+
+    Object payloads use shallow key checks via ``JSON_VALUE`` /
+    ``JSON_QUERY`` / ``OPENJSON``. Nested deep-merge containment is not
+    emulated.
+    """
+    value = constraint.value
+    if isinstance(value, dict):
+        if not value:
+            # Align with PostgreSQL ``@> '{}'``: require a non-NULL JSON object.
+            return cast(
+                ColumnElement[bool],
+                column.is_not(None)
+                & (func.isjson(column) == 1)
+                & func.json_query(column, "$").is_not(None),
+            )
+        parts: list[ColumnElement[bool]] = []
+        for key, expected in value.items():
+            path = _json_path_for_key(key)
+            key_text = str(key)
+            if expected is None:
+                parts.append(_openjson_key_exists(column, key_text, json_type="null"))
+            elif isinstance(expected, (dict, list)):
+                compact = _compact_dumps(expected)
+                parts.append(
+                    cast(
+                        ColumnElement[bool],
+                        func.json_query(column, path)
+                        == func.json_query(sa_cast(literal(compact), String), "$"),
+                    )
+                )
+            elif isinstance(expected, bool):
+                expected_text = "true" if expected else "false"
+                parts.append(
+                    cast(
+                        ColumnElement[bool],
+                        func.json_value(column, path) == literal(expected_text),
+                    )
+                )
+            elif isinstance(expected, str):
+                parts.append(
+                    cast(
+                        ColumnElement[bool],
+                        func.json_value(column, path) == literal(expected),
+                    )
+                )
+            else:
+                parts.append(
+                    cast(
+                        ColumnElement[bool],
+                        func.json_value(column, path) == literal(str(expected)),
+                    )
+                )
+        expression = parts[0]
+        for part in parts[1:]:
+            expression = expression & part
+        return cast(ColumnElement[bool], expression)
+
+    compact = _compact_dumps(value)
+    return cast(
+        ColumnElement[bool],
+        type_coerce(column, String) == func.json_query(sa_cast(literal(compact), String), "$"),
+    )
+
+
+def translate_json_has_key(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Translate ``json_has_key`` via ``OPENJSON`` key presence (includes JSON null)."""
+    return _openjson_key_exists(column, str(constraint.value))

sqlrules_mssql-1.0.0/src/sqlrules_mssql/length.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlalchemy import func, literal
+from sqlalchemy.sql.elements import ColumnElement
+
+from sqlrules.ir import CompilationContext, Constraint
+
+
+def _char_length(column: ColumnElement[Any]) -> ColumnElement[Any]:
+    """Character length including trailing spaces (``LEN`` alone strips them)."""
+    return func.len(column.concat(literal("."))) - 1
+
+
+def translate_min_length(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Override portable ``length`` with trailing-space-aware SQL Server length."""
+    return cast(ColumnElement[bool], _char_length(column) >= constraint.value)
+
+
+def translate_max_length(
+    constraint: Constraint,
+    column: ColumnElement[Any],
+    context: CompilationContext,
+) -> ColumnElement[bool]:
+    """Override portable ``length`` with trailing-space-aware SQL Server length."""
+    return cast(ColumnElement[bool], _char_length(column) <= constraint.value)

sqlrules_mssql-1.0.0/src/sqlrules_mssql/type_check.py

@@ -0,0 +1,232 @@
+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 import cast as sa_cast
+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
+
+_UUID_LIKE = (
+    "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]"
+    "[0-9A-Fa-f][0-9A-Fa-f]-"
+    "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]-"
+    "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]-"
+    "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]-"
+    "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]"
+    "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]"
+)
+
+
+def _is_type(column: ColumnElement[Any], *bases: type[TypeEngine[Any]]) -> bool:
+    col_type = column.type
+    if isinstance(col_type, NullType):
+        return False
+    return isinstance(col_type, bases)
+
+
+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):
+        return cast(ColumnElement[bool], column.isnot(None))
+    if spec.strict:
+        _unsupported(
+            field,
+            spec,
+            "SQL Server strict int type_check requires an Integer column.",
+        )
+    if _is_type(column, String):
+        unsigned = column.like("[0-9]%") & ~column.like("%[^0-9]%")
+        signed = column.like("[-+][0-9]%") & ~column.like("[-+]%[^0-9]%")
+        return cast(ColumnElement[bool], unsigned | signed)
+    if _is_type(column, Float, Numeric):
+        return cast(
+            ColumnElement[bool],
+            column == sa_cast(sa_cast(column, Integer), Float),
+        )
+    _unsupported(
+        field,
+        spec,
+        "SQL Server 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, Integer):
+            return cast(ColumnElement[bool], column.in_((True, False, 0, 1)))
+        _unsupported(
+            field,
+            spec,
+            "SQL Server strict bool type_check requires a Boolean/Integer column.",
+        )
+    _unsupported(
+        field,
+        spec,
+        "SQL Server lax bool type_check is not supported. Use strict=True.",
+    )
+    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,
+        "SQL Server str type_check requires a String/Text column.",
+    )
+    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,
+            "SQL Server strict float/Decimal type_check requires a numeric column.",
+        )
+    if _is_type(column, String):
+        _unsupported(
+            field,
+            spec,
+            "SQL Server lax float/Decimal type_check on String columns is not "
+            "supported (no portable numeric shape check). Use a numeric column "
+            "or strict=True with Float/Numeric/Integer.",
+        )
+    _unsupported(
+        field,
+        spec,
+        "SQL Server float/Decimal type_check supports Float, Numeric, or Integer columns.",
+    )
+    raise AssertionError("unreachable")
+
+
+def _predicate_temporal(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+    *,
+    sa_types: tuple[type[TypeEngine[Any]], ...],
+) -> ColumnElement[bool]:
+    if _is_type(column, *sa_types):
+        return cast(ColumnElement[bool], column.isnot(None))
+    type_name = spec.python_type.__name__
+    _unsupported(
+        field,
+        spec,
+        f"SQL Server {type_name} type_check requires a typed {type_name} column "
+        "(string date parsing is not emitted without a portable regex).",
+    )
+    raise AssertionError("unreachable")
+
+
+def _predicate_uuid(
+    column: ColumnElement[Any],
+    spec: TypeSpec,
+    field: str,
+) -> ColumnElement[bool]:
+    if "uuid" in type(column.type).__name__.lower():
+        return cast(ColumnElement[bool], column.isnot(None))
+    if spec.strict:
+        _unsupported(
+            field,
+            spec,
+            "SQL Server strict UUID type_check requires a UUID column.",
+        )
+    if _is_type(column, String):
+        return cast(ColumnElement[bool], column.like(_UUID_LIKE))
+    _unsupported(
+        field,
+        spec,
+        "SQL Server 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,))
+    if python_type is datetime:
+        return _predicate_temporal(column, spec, field, sa_types=(DateTime,))
+    if python_type is time:
+        return _predicate_temporal(column, spec, field, sa_types=(Time,))
+    if python_type is UUID:
+        return _predicate_uuid(column, spec, field)
+    _unsupported(
+        field,
+        spec,
+        f"SQL Server 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 SQL Server shape/type predicates."""
+    del context
+    spec = type_spec(constraint.value)
+    predicate = _build_predicate(column, spec, constraint.field)
+    return _wrap_none(column, predicate, allow_none=spec.allow_none)

sqlrules_mssql-1.0.0/tests/test_mssql_plugin.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import pytest
+from pydantic import BaseModel, Field
+from sqlalchemy import Column, MetaData, String, Table, Text
+from sqlalchemy.dialects import mssql
+from sqlrules_mssql import MssqlPlugin, __version__
+
+from sqlrules import Compiler, JsonContains, JsonHasKey, UnsupportedConstraintError
+from sqlrules.conformance import assert_builtins_preserved, assert_plugin_api_compatible
+
+
+def test_version() -> None:
+    assert __version__ == "1.0.0"
+
+
+def test_plugin_api() -> None:
+    plugin = MssqlPlugin()
+    assert_plugin_api_compatible(plugin)
+    assert_builtins_preserved(plugin, on_conflict="replace")
+
+
+def test_length_uses_trailing_space_aware_len() -> None:
+    class Filter(BaseModel):
+        name: Annotated[str, Field(min_length=2, max_length=10)]
+
+    table = Table("items", MetaData(), Column("name", String))
+    rules = Compiler(
+        plugins=[MssqlPlugin()],
+        dialect="mssql",
+        cache=False,
+    ).compile(Filter, table)
+    dialect = mssql.dialect()
+    min_sql = str(rules["name"][0].compile(dialect=dialect)).lower()
+    max_sql = str(rules["name"][1].compile(dialect=dialect)).lower()
+    assert "len(" in min_sql and ">=" in min_sql
+    assert "len(" in max_sql and "<=" in max_sql
+    assert "||" in min_sql or "concat" in min_sql or "+" in min_sql
+    assert "length(" not in min_sql
+    assert "length(" not in max_sql
+
+
+def test_json_operators_compile() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[dict[str, Any], JsonContains({"active": True}), JsonHasKey("active")]
+
+    table = Table("items", MetaData(), Column("meta", Text))
+    rules = Compiler(
+        plugins=[MssqlPlugin()],
+        dialect="mssql",
+        cache=False,
+    ).compile(Filter, table)
+    assert len(rules["meta"]) == 2
+    dialect = mssql.dialect()
+    contains_sql = str(rules["meta"][0].compile(dialect=dialect)).lower()
+    has_key_sql = str(rules["meta"][1].compile(dialect=dialect)).lower()
+    assert "json_value" in contains_sql
+    assert "openjson" in has_key_sql
+
+
+def test_json_contains_none_uses_openjson_null_type() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[dict[str, Any], JsonContains({"a": None})]
+
+    table = Table("items", MetaData(), Column("meta", Text))
+    rules = Compiler(
+        plugins=[MssqlPlugin()],
+        dialect="mssql",
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(
+        rules["meta"][0].compile(
+            dialect=mssql.dialect(),
+            compile_kwargs={"literal_binds": True},
+        )
+    ).lower()
+    assert "openjson" in compiled
+    assert "null" in compiled
+    assert "'none'" not in compiled
+
+
+def test_json_contains_nested_uses_compact_json_query() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[dict[str, Any], JsonContains({"nested": {"x": 1}})]
+
+    table = Table("items", MetaData(), Column("meta", Text))
+    rules = Compiler(
+        plugins=[MssqlPlugin()],
+        dialect="mssql",
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(
+        rules["meta"][0].compile(
+            dialect=mssql.dialect(),
+            compile_kwargs={"literal_binds": True},
+        )
+    )
+    assert '{"x":1}' in compiled
+    assert '{"x": 1}' not in compiled
+
+
+def test_pattern_remains_unsupported() -> None:
+    class Filter(BaseModel):
+        name: Annotated[str, Field(pattern=r"^A")]
+
+    table = Table("items", MetaData(), Column("name", String))
+    with pytest.raises(UnsupportedConstraintError, match="pattern"):
+        Compiler(
+            plugins=[MssqlPlugin()],
+            dialect="mssql",
+            cache=False,
+        ).compile(Filter, table)
+
+
+def test_empty_json_contains_requires_object() -> None:
+    class Filter(BaseModel):
+        meta: Annotated[dict[str, Any], JsonContains({})]
+
+    table = Table("items", MetaData(), Column("meta", Text))
+    rules = Compiler(
+        plugins=[MssqlPlugin()],
+        dialect="mssql",
+        cache=False,
+    ).compile(Filter, table)
+    assert len(rules["meta"]) == 1
+    compiled = str(
+        rules["meta"][0].compile(
+            dialect=mssql.dialect(),
+            compile_kwargs={"literal_binds": True},
+        )
+    ).lower()
+    assert "isjson" in compiled
+    assert "json_query" in compiled
+
+
+def test_type_check_lax_float_string_unsupported() -> None:
+    class Filter(BaseModel):
+        score: float
+
+    table = Table("rows", MetaData(), Column("score", String))
+    with pytest.raises(UnsupportedConstraintError, match="float"):
+        Compiler(
+            plugins=[MssqlPlugin()],
+            dialect="mssql",
+            emit_type_checks=True,
+            cache=False,
+        ).compile(Filter, table)
+
+
+def test_type_check_int_integer_column() -> None:
+    from sqlalchemy import Integer
+
+    class Filter(BaseModel):
+        age: int
+
+    table = Table("users", MetaData(), Column("age", Integer))
+    rules = Compiler(
+        plugins=[MssqlPlugin()],
+        dialect="mssql",
+        emit_type_checks=True,
+        cache=False,
+    ).compile(Filter, table)
+    compiled = str(rules["age"][0].compile(dialect=mssql.dialect()))
+    assert "IS NOT NULL" in compiled.upper()