sqlproof 0.1.0a1__py3-none-any.whl

sqlproof/generators/constraints.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import re
+from decimal import Decimal
+from typing import Any
+
+from hypothesis import strategies as st
+from hypothesis.strategies import SearchStrategy
+
+from sqlproof.schema.model import CheckConstraint, Column
+
+
+def refine_for_checks(
+    column: Column,
+    strategy: SearchStrategy[Any],
+    checks: tuple[CheckConstraint, ...],
+) -> SearchStrategy[Any]:
+    for check in checks:
+        strategy = _refine_for_check(column, strategy, check.expression)
+    return strategy
+
+
+def _refine_for_check(
+    column: Column,
+    strategy: SearchStrategy[Any],
+    expression: str,
+) -> SearchStrategy[Any]:
+    expression = _normalize_check_expression(expression)
+    in_set_match = re.fullmatch(
+        rf"{re.escape(column.name)}\s+IN\s*\((?P<values>.+)\)",
+        expression,
+        flags=re.IGNORECASE,
+    )
+    if in_set_match is not None:
+        values = tuple(
+            _parse_sql_literal(value) for value in in_set_match.group("values").split(",")
+        )
+        return _sampled_values_for_column(column, values)
+
+    any_array_match = re.fullmatch(
+        rf"\(?\s*{re.escape(column.name)}\s*=\s*ANY\s*"
+        r"\(\s*ARRAY\[(?P<values>.+)\]\s*\)\s*\)?",
+        expression,
+        flags=re.IGNORECASE,
+    )
+    if any_array_match is not None:
+        values = tuple(
+            _parse_sql_literal(value) for value in any_array_match.group("values").split(",")
+        )
+        return _sampled_values_for_column(column, values)
+
+    length_match = re.fullmatch(
+        rf"(?:char_length|length)\s*\(\s*{re.escape(column.name)}\s*\)\s*"
+        rf"(?P<op>>=|>|<=|<|=)\s*(?P<value>\d+)",
+        expression,
+        flags=re.IGNORECASE,
+    )
+    if length_match is not None:
+        direct = _direct_length_strategy(
+            column, length_match.group("op"), int(length_match.group("value"))
+        )
+        if direct is not None:
+            return direct
+
+    range_match = re.fullmatch(
+        rf"{re.escape(column.name)}\s*(?P<op>>=|>|<=|<)\s*(?P<value>-?\d+(?:\.\d+)?)",
+        expression,
+        flags=re.IGNORECASE,
+    )
+    if range_match is None:
+        return strategy
+    op = range_match.group("op")
+    raw_value = Decimal(range_match.group("value"))
+    direct = _direct_range_strategy(column, op, raw_value)
+    if direct is not None:
+        return direct
+
+    def predicate(value: Any) -> bool:
+        if value is None:
+            return True
+        comparable = Decimal(str(value))
+        if op == ">=":
+            return comparable >= raw_value
+        if op == ">":
+            return comparable > raw_value
+        if op == "<=":
+            return comparable <= raw_value
+        return comparable < raw_value
+
+    return strategy.filter(predicate)
+
+
+def _normalize_check_expression(expression: str) -> str:
+    value = expression.strip()
+    match = re.fullmatch(r"CHECK\s*\((?P<inner>.*)\)", value, flags=re.IGNORECASE | re.DOTALL)
+    if match is not None:
+        return match.group("inner").strip()
+    return value
+
+
+def _parse_sql_literal(value: str) -> Any:
+    stripped = value.strip()
+    cast_match = re.fullmatch(
+        r"(?P<literal>'(?:''|[^'])*'|-?\d+(?:\.\d+)?)(?:\s*::[\w. ]+)?",
+        stripped,
+    )
+    if cast_match is not None:
+        stripped = cast_match.group("literal")
+    if stripped.startswith("'") and stripped.endswith("'"):
+        return stripped[1:-1].replace("''", "'")
+    try:
+        return int(stripped)
+    except ValueError:
+        try:
+            return Decimal(stripped)
+        except Exception:
+            return stripped
+
+
+def _sampled_values_for_column(column: Column, values: tuple[Any, ...]) -> SearchStrategy[Any]:
+    strategy = st.sampled_from(values)
+    if column.nullable:
+        return st.none() | strategy
+    return strategy
+
+
+def _direct_length_strategy(column: Column, op: str, value: int) -> SearchStrategy[str] | None:
+    name = column.type.name
+    if name not in {"text", "citext", "varchar", "character varying", "char", "character"}:
+        return None
+    min_size = 0
+    max_size = column.type.modifiers[0] if column.type.modifiers else 255
+    if op == "=":
+        min_size = value
+        max_size = value
+    elif op == "<=":
+        max_size = min(max_size, value)
+    elif op == "<":
+        max_size = min(max_size, max(0, value - 1))
+    elif op == ">=":
+        min_size = value
+    elif op == ">":
+        min_size = value + 1
+    if min_size > max_size:
+        return st.nothing()
+    return st.text(min_size=min_size, max_size=max_size)
+
+
+def _direct_range_strategy(
+    column: Column,
+    op: str,
+    raw_value: Decimal,
+) -> SearchStrategy[Any] | None:
+    name = column.type.name
+    if op not in {">=", ">"}:
+        return None
+    minimum = raw_value if op == ">=" else raw_value + Decimal("1")
+    if name in {"integer", "int", "int4"}:
+        return st.integers(max(int(minimum), -2_147_483_648), 2_147_483_647)
+    if name in {"bigint", "int8"}:
+        return st.integers(max(int(minimum), -(2**63)), 2**63 - 1)
+    if name in {"numeric", "decimal"}:
+        places = column.type.modifiers[1] if len(column.type.modifiers) > 1 else 2
+        return st.decimals(
+            min_value=minimum,
+            max_value=Decimal("1000000"),
+            places=places,
+            allow_nan=False,
+            allow_infinity=False,
+        )
+    return None
+
+
+def unique_rows(rows: list[dict[str, Any]], columns: tuple[str, ...]) -> bool:
+    seen: set[tuple[Any, ...]] = set()
+    for row in rows:
+        key = tuple(row[column] for column in columns)
+        if key in seen:
+            return False
+        seen.add(key)
+    return True

sqlproof/generators/functions.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class FunctionCall:
+    sql: str
+    overload_name: str

sqlproof/generators/graph.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from hypothesis import strategies as st
+from hypothesis.strategies import SearchStrategy
+
+from sqlproof.schema.dependency_graph import insertion_order
+from sqlproof.schema.model import SchemaInfo
+
+from .rows import ColumnOverrides, table_rows_strategy
+
+Dataset = dict[str, list[dict[str, Any]]]
+SizeSpec = int | SearchStrategy[int]
+
+
+def dataset_strategy(
+    schema: SchemaInfo,
+    *,
+    sizes: Mapping[str, SizeSpec],
+    external_parent_rows: Mapping[str, list[dict[str, Any]]] | None = None,
+    columns: ColumnOverrides | None = None,
+) -> SearchStrategy[Dataset]:
+    ordered_tables = insertion_order(schema.tables)
+    external_parent_rows = external_parent_rows or {}
+
+    @st.composite
+    def dataset(draw: st.DrawFn) -> Dataset:
+        rows_by_table: Dataset = {}
+        for table in ordered_tables:
+            count = _draw_size(draw, sizes.get(table.name, 0))
+            available_parent_rows = {**external_parent_rows, **rows_by_table}
+            rows_by_table[table.name] = draw(
+                table_rows_strategy(
+                    table,
+                    count=count,
+                    parent_rows=available_parent_rows,
+                    rows_by_table=rows_by_table,
+                    columns=columns,
+                )
+            )
+        return rows_by_table
+
+    return dataset()
+
+
+def _draw_size(draw: st.DrawFn, size: SizeSpec) -> int:
+    if isinstance(size, int):
+        return size
+    return draw(size)

sqlproof/generators/rows.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Any, cast
+from uuid import UUID
+
+from hypothesis import strategies as st
+from hypothesis.strategies import SearchStrategy
+
+from sqlproof.exceptions import SqlProofGenerationError
+from sqlproof.generators.columns import strategy_for_column
+from sqlproof.generators.constraints import refine_for_checks
+from sqlproof.schema.model import ForeignKey, Table
+
+DatasetRows = dict[str, list[dict[str, Any]]]
+ColumnOverrides = Mapping[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ColumnContext:
+    table: Table
+    column_name: str
+    row_index: int
+    row: dict[str, Any]
+    table_rows: list[dict[str, Any]]
+    rows_by_table: DatasetRows
+
+
+def table_rows_strategy(
+    table: Table,
+    *,
+    count: int,
+    parent_rows: DatasetRows | None = None,
+    rows_by_table: DatasetRows | None = None,
+    columns: ColumnOverrides | None = None,
+) -> SearchStrategy[list[dict[str, Any]]]:
+    parent_rows = parent_rows or {}
+    rows_by_table = rows_by_table or {}
+    columns = columns or {}
+
+    @st.composite
+    def rows(draw: st.DrawFn) -> list[dict[str, Any]]:
+        generated: list[dict[str, Any]] = []
+        for index in range(count):
+            row: dict[str, Any] = {}
+            for column in table.columns:
+                if column.name in table.primary_key and len(table.primary_key) == 1:
+                    row[column.name] = _unique_value(column.name, column.type.name, index)
+                    continue
+                if column.is_generated:
+                    continue
+                override = _column_override(columns, table, column.name)
+                if override is not None:
+                    context = ColumnContext(
+                        table=table,
+                        column_name=column.name,
+                        row_index=index,
+                        row=row,
+                        table_rows=generated,
+                        rows_by_table=rows_by_table,
+                    )
+                    row[column.name] = _draw_override(draw, override, context)
+                    continue
+                if column.default is not None:
+                    continue
+                fk = _foreign_key_for_column(table, column.name)
+                if fk is not None:
+                    parent_key = _parent_rows_key(fk, parent_rows)
+                    if parent_key is not None:
+                        parents = parent_rows[parent_key]
+                        if parents:
+                            parent = draw(st.sampled_from(parents))
+                            row[column.name] = parent[fk.referenced_columns[0]]
+                            continue
+                    if column.nullable:
+                        row[column.name] = None
+                        continue
+                    msg = (
+                        f"Cannot generate {table.name}.{column.name}: "
+                        f"required foreign key has no available parent rows for "
+                        f"{fk.referenced_table}.{fk.referenced_columns[0]}."
+                    )
+                    raise SqlProofGenerationError(msg)
+                if _is_single_column_unique(table, column.name):
+                    row[column.name] = _unique_value(column.name, column.type.name, index)
+                    continue
+                strategy = refine_for_checks(
+                    column, strategy_for_column(column), table.check_constraints
+                )
+                row[column.name] = draw(strategy)
+            generated.append(row)
+        return generated
+
+    return rows()
+
+
+def _column_override(
+    overrides: ColumnOverrides,
+    table: Table,
+    column_name: str,
+) -> Any | None:
+    for key in (f"{table.qualified_name}.{column_name}", f"{table.name}.{column_name}"):
+        if key in overrides:
+            return overrides[key]
+    return None
+
+
+def _draw_override(draw: st.DrawFn, override: Any, context: ColumnContext) -> Any:
+    if isinstance(override, SearchStrategy):
+        return draw(cast(SearchStrategy[Any], override))
+    if callable(override):
+        return override(context)
+    return override
+
+
+def _foreign_key_for_column(table: Table, column_name: str) -> ForeignKey | None:
+    for foreign_key in table.foreign_keys:
+        if foreign_key.columns == (column_name,):
+            return foreign_key
+    return None
+
+
+def _parent_rows_key(
+    foreign_key: ForeignKey,
+    parent_rows: dict[str, list[dict[str, Any]]],
+) -> str | None:
+    if foreign_key.referenced_schema is not None:
+        qualified = f"{foreign_key.referenced_schema}.{foreign_key.referenced_table}"
+        if qualified in parent_rows:
+            return qualified
+    if foreign_key.referenced_table in parent_rows:
+        return foreign_key.referenced_table
+    return None
+
+
+def _is_single_column_unique(table: Table, column_name: str) -> bool:
+    return any(columns == (column_name,) for columns in table.unique_constraints)
+
+
+def _unique_value(column_name: str, type_name: str, index: int) -> Any:
+    normalized = type_name.lower()
+    value = index + 1
+    if normalized in {"smallint", "int2", "integer", "int", "int4", "serial"}:
+        return value
+    if normalized in {"bigint", "int8", "bigserial"}:
+        return value
+    if normalized in {"numeric", "decimal"}:
+        return Decimal(value)
+    if normalized == "uuid":
+        return str(UUID(int=value))
+    return f"{column_name}_{value}"

sqlproof/generators/sampling.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import warnings
+from typing import TypeVar
+
+from hypothesis.errors import NonInteractiveExampleWarning
+from hypothesis.strategies import SearchStrategy
+
+T = TypeVar("T")
+
+
+def draw_example(strategy: SearchStrategy[T]) -> T:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", NonInteractiveExampleWarning)
+        return strategy.example()

sqlproof/generators/well_known.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from hypothesis import strategies as st
+from hypothesis.strategies import SearchStrategy
+
+
+def slugs(min_length: int = 1, max_length: int = 64) -> SearchStrategy[str]:
+    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789-"
+    return st.text(alphabet=alphabet, min_size=min_length, max_size=max_length).filter(
+        lambda value: not value.startswith("-") and not value.endswith("-")
+    )
+
+
+def emails(domains: list[str] | None = None) -> SearchStrategy[str]:
+    domain_strategy = (
+        st.sampled_from(domains) if domains else st.sampled_from(["example.com", "test.dev"])
+    )
+    local = st.text(
+        alphabet="abcdefghijklmnopqrstuvwxyz0123456789._-",
+        min_size=1,
+        max_size=32,
+    ).filter(lambda value: value.strip("."))
+    return st.builds(_join_email, local, domain_strategy)
+
+
+def urls(
+    schemes: tuple[str, ...] = ("https", "http"),
+    *,
+    include_path: bool = True,
+    include_query: bool = True,
+    include_fragment: bool = False,
+) -> SearchStrategy[str]:
+    scheme = st.sampled_from(schemes)
+    host = st.sampled_from(["example.com", "sqlproof.dev", "localhost"])
+    path = slugs(max_length=20).map(lambda value: f"/{value}") if include_path else st.just("")
+    query = st.text(max_size=10).map(lambda value: f"?q={value}") if include_query else st.just("")
+    fragment = (
+        slugs(max_length=10).map(lambda value: f"#{value}") if include_fragment else st.just("")
+    )
+    return st.builds(_join_url, scheme, host, path, query, fragment)
+
+
+def phone_numbers(country: str | None = None) -> SearchStrategy[str]:
+    prefix = "+1" if country in {None, "US", "CA"} else "+44"
+    return st.integers(2_000_000_000, 9_999_999_999).map(lambda number: f"{prefix}{number}")
+
+
+def postal_codes(country: str) -> SearchStrategy[str]:
+    if country.upper() in {"US", "USA"}:
+        return st.integers(0, 99_999).map(lambda number: f"{number:05d}")
+    return st.text(alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ", min_size=3, max_size=10)
+
+
+def _join_email(lhs: str, rhs: str) -> str:
+    return f"{lhs}@{rhs}"
+
+
+def _join_url(scheme: str, host: str, path: str, query: str, fragment: str) -> str:
+    return f"{scheme}://{host}{path}{query}{fragment}"

sqlproof/pytest_plugin.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import pytest
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("sqlproof")
+    group.addoption("--sqlproof-seed", action="store", type=int, help="Fix the SqlProof seed.")
+    group.addoption(
+        "--sqlproof-runs", action="store", type=int, help="Override SqlProof run count."
+    )
+    group.addoption(
+        "--sqlproof-show-counterexample",
+        action="store_true",
+        help="Print full SqlProof counterexamples.",
+    )
+    group.addoption("--sqlproof-coverage", action="store_true", help="Enable PL/pgSQL coverage.")
+    group.addoption(
+        "--sqlproof-diversity-report",
+        action="store_true",
+        help="Print generator diversity report.",
+    )
+    group.addoption("--sqlproof-postgres-image", action="store", help="Override Postgres image.")
+    group.addoption("--sqlproof-verbose", action="store_true", help="Enable DEBUG logging.")

sqlproof/reporter/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from sqlproof.reporter.json_io import write_counterexample
+
+__all__ = ["write_counterexample"]

sqlproof/reporter/console.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlproof.coverage.schema_shape import summarize_dataset_shape
+
+
+def format_failure(payload: dict[str, Any]) -> str:
+    lines = [
+        f"Property failed: {payload.get('property_name', 'counterexample')}",
+        f"Failure: {payload.get('failure', {}).get('kind', 'unknown')}: "
+        f"{payload.get('failure', {}).get('message', '')}",
+    ]
+    if payload.get("row_context"):
+        lines.append(f"Row context: {payload['row_context']}")
+    dataset = payload.get("dataset")
+    if isinstance(dataset, dict):
+        shape = summarize_dataset_shape(cast(dict[str, list[dict[str, Any]]], dataset))
+        lines.append(f"Dataset shape: {shape}")
+    return "\n".join(lines)

sqlproof/reporter/json_io.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import json
+from dataclasses import is_dataclass
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+
+def write_counterexample(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(payload, default=_json_default, indent=2, sort_keys=True), encoding="utf-8"
+    )
+
+
+def _json_default(value: Any) -> Any:
+    if isinstance(value, Decimal | datetime | date | time | UUID):
+        return str(value)
+    if isinstance(value, timedelta):
+        return value.total_seconds()
+    if is_dataclass(value):
+        return value.__dict__
+    raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")

sqlproof/runners/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from sqlproof.runners.migration import migration
+from sqlproof.runners.overload import function_overloads
+from sqlproof.runners.property import Check, sqlproof
+from sqlproof.runners.rls import rls
+from sqlproof.runners.stateful import stateful
+
+sqlproof.stateful = stateful  # type: ignore[attr-defined]
+sqlproof.migration = migration  # type: ignore[attr-defined]
+sqlproof.rls = rls  # type: ignore[attr-defined]
+sqlproof.function_overloads = function_overloads  # type: ignore[attr-defined]
+
+__all__ = ["Check", "function_overloads", "migration", "rls", "sqlproof", "stateful"]

sqlproof/runners/db.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any, cast
+
+import psycopg
+from psycopg.rows import dict_row
+
+from sqlproof.client import PsycopgSqlProofClient, SqlProofClient
+from sqlproof.config import SqlProofConfig
+from sqlproof.exceptions import SqlProofUsageError
+
+
+class DBManager:
+    def __init__(self, config: SqlProofConfig) -> None:
+        self.config = config
+        self.started = False
+        self._connection: Any | None = None
+
+    def start(self) -> None:
+        if self.config.connection_string is None:
+            msg = "DBManager requires a connection_string for real Postgres execution."
+            raise SqlProofUsageError(msg)
+        if self.started:
+            return
+        self._connection = psycopg.connect(
+            conninfo=self.config.connection_string,
+            autocommit=False,
+            row_factory=cast(Any, dict_row),
+        )
+        self.started = True
+
+    @contextmanager
+    def acquire(self, *, persistent: bool = False) -> Generator[SqlProofClient]:
+        del persistent
+        if self._connection is None:
+            self.start()
+        if self._connection is None:
+            msg = "DBManager failed to establish a database connection."
+            raise SqlProofUsageError(msg)
+        yield PsycopgSqlProofClient(self._connection)
+
+    def stop(self) -> None:
+        if self._connection is not None:
+            self._connection.close()
+            self._connection = None
+        self.started = False

sqlproof/runners/migration.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any, cast
+
+from hypothesis import HealthCheck, given, settings
+
+from sqlproof.generators.graph import SizeSpec, dataset_strategy
+
+
+def migration(
+    proof: Any,
+    *,
+    before_schema: str,
+    migration: str,
+    sizes: Mapping[str, SizeSpec],
+    **kwargs: object,
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    del before_schema
+    runs = int(cast(Any, kwargs.pop("runs", 1)))
+
+    def decorate(function: Callable[..., None]) -> Callable[..., None]:
+        def wrapped() -> None:
+            @given(dataset_strategy(proof.schema_info, sizes=sizes))
+            @settings(
+                max_examples=runs,
+                deadline=None,
+                suppress_health_check=[HealthCheck.function_scoped_fixture],
+            )
+            def execute(dataset: dict[str, list[dict[str, Any]]]) -> None:
+                with (
+                    proof.client_for_dataset(dataset) as before,
+                    proof.client_for_dataset(dataset) as after,
+                ):
+                    _execute_migration(after, migration)
+                    function(before, after)
+
+            execute()
+
+        return wrapped
+
+    return decorate
+
+
+def _execute_migration(db: Any, migration: str) -> None:
+    path = Path(migration)
+    if path.exists():
+        db.execute_file(path)
+    else:
+        db.execute(migration)