sqlproof 0.1.0a1__py3-none-any.whl

sqlproof/runners/overload.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from sqlproof.generators.functions import FunctionCall
+
+
+def function_overloads(
+    proof: Any,
+    *,
+    function: str,
+    **kwargs: object,
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    del kwargs
+
+    def decorate(callback: Callable[..., None]) -> Callable[..., None]:
+        def wrapped() -> None:
+            calls = _function_calls(proof, function)
+            if len(calls) < 2:
+                calls = (
+                    FunctionCall(sql=f"{function}()", overload_name=f"{function}/0"),
+                    FunctionCall(sql=f"{function}()", overload_name=f"{function}/0"),
+                )
+            with proof.client_for_dataset({}) as db:
+                callback(db, calls[0], calls[1])
+
+        return wrapped
+
+    return decorate
+
+
+def _function_calls(proof: Any, function_name: str) -> tuple[FunctionCall, ...]:
+    calls: list[FunctionCall] = []
+    for function in proof.schema_info.functions:
+        if function.name != function_name:
+            continue
+        arguments = ", ".join("%s" for _arg in function.arg_types)
+        overload = f"{function.name}/{len(function.arg_types)}"
+        calls.append(FunctionCall(sql=f"{function.name}({arguments})", overload_name=overload))
+    return tuple(calls)

sqlproof/runners/property.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable, Generator, Mapping
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, ParamSpec, TypeVar
+
+from hypothesis import HealthCheck, given, settings
+
+from sqlproof.exceptions import SqlProofPropertyFailure
+from sqlproof.generators.graph import SizeSpec, dataset_strategy
+from sqlproof.reporter.json_io import write_counterexample
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class Check:
+    def __init__(self) -> None:
+        self.row_context: dict[str, Any] | None = None
+
+    @contextmanager
+    def row(self, **context: Any) -> Generator[None]:
+        previous = self.row_context
+        self.row_context = context
+        try:
+            yield
+        finally:
+            if previous is not None:
+                self.row_context = previous
+
+    def label(self, name: str) -> None:
+        del name
+
+
+def sqlproof(
+    proof: Any,
+    *,
+    sizes: Mapping[str, SizeSpec],
+    runs: int = 100,
+    seed: int | None = None,
+    timeout_ms: int = 5000,
+    commit: bool = False,
+    failure_dir: str | Path = ".sqlproof/failures",
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    del seed, timeout_ms, commit
+
+    def decorate(function: Callable[..., None]) -> Callable[..., None]:
+        def wrapped() -> None:
+            run_property(
+                proof,
+                function,
+                sizes=sizes,
+                runs=runs,
+                failure_dir=Path(failure_dir),
+            )
+
+        wrapped.__name__ = function.__name__
+        wrapped.__doc__ = function.__doc__
+        return wrapped
+
+    return decorate
+
+
+def run_property(
+    proof: Any,
+    function: Callable[..., None],
+    *,
+    sizes: Mapping[str, SizeSpec],
+    runs: int,
+    failure_dir: Path,
+) -> None:
+    if hasattr(proof, "dataset_strategy"):
+        strategy = proof.dataset_strategy(sizes=sizes)
+    else:
+        strategy = dataset_strategy(proof.schema_info, sizes=sizes)
+    signature = inspect.signature(function)
+    wants_check = "check" in signature.parameters
+    run_count = 0
+
+    @given(strategy)
+    @settings(
+        max_examples=runs,
+        deadline=None,
+        suppress_health_check=[HealthCheck.function_scoped_fixture],
+    )
+    def execute(dataset: dict[str, list[dict[str, Any]]]) -> None:
+        nonlocal run_count
+        run_count += 1
+        check = Check()
+        try:
+            with proof.client_for_dataset(dataset) as client:
+                if wants_check:
+                    function(client, check)
+                else:
+                    function(client)
+        except Exception as exc:
+            payload: dict[str, Any] = {
+                "$schema": "https://sqlproof.dev/schemas/counterexample-v1.json",
+                "version": 1,
+                "property_name": function.__name__,
+                "seed": None,
+                "runs": run_count,
+                "shrink_steps": 0,
+                "schema_fingerprint": proof.schema_fingerprint,
+                "row_context": check.row_context or {},
+                "dataset": dataset,
+                "failure": {
+                    "kind": type(exc).__name__,
+                    "message": str(exc),
+                    "locals": {},
+                    "traceback": [],
+                },
+            }
+            write_counterexample(failure_dir / f"{function.__name__}.json", payload)
+            raise SqlProofPropertyFailure(str(exc), counterexample=payload) from exc
+
+    execute()

sqlproof/runners/rls.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any, cast
+
+from hypothesis import HealthCheck, given, settings
+
+from sqlproof.generators.graph import SizeSpec, dataset_strategy
+
+
+def rls(
+    proof: Any,
+    *,
+    sizes: Mapping[str, SizeSpec],
+    roles: list[str],
+    mode: str = "postgrest",
+    **kwargs: object,
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
+    del mode
+    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:
+                for role in roles:
+                    with proof.client_for_dataset(dataset) as db:
+                        db.execute(f"SET LOCAL ROLE {role}")
+                        function(db, {"role": role}, dataset)
+
+            execute()
+
+        return wrapped
+
+    return decorate

sqlproof/runners/stateful.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any, cast
+
+from hypothesis import HealthCheck, given, settings
+
+from sqlproof.generators.graph import SizeSpec, dataset_strategy
+
+
+def stateful(
+    proof: Any, *, sizes: Mapping[str, SizeSpec], **kwargs: object
+) -> Callable[[type[Any]], type[Any]]:
+    runs = int(cast(Any, kwargs.pop("runs", 1)))
+
+    def decorate(cls: type[Any]) -> type[Any]:
+        original_run = getattr(cls, "run", None)
+
+        def run(self: Any) -> 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 db:
+                    if original_run is not None:
+                        original_run(self, db)
+
+            execute()
+
+        cls.run = run
+        return cls
+
+    return decorate

sqlproof/schema/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from sqlproof.schema.dependency_graph import insertion_order
+from sqlproof.schema.fingerprint import compute
+from sqlproof.schema.model import (
+    CheckConstraint,
+    Column,
+    ForeignKey,
+    Function,
+    PgType,
+    SchemaInfo,
+    Table,
+)
+from sqlproof.schema.parse_sql import parse_schema_sql
+
+__all__ = [
+    "CheckConstraint",
+    "Column",
+    "ForeignKey",
+    "Function",
+    "PgType",
+    "SchemaInfo",
+    "Table",
+    "compute",
+    "insertion_order",
+    "parse_schema_sql",
+]

sqlproof/schema/dependency_graph.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from collections import defaultdict, deque
+
+from sqlproof.exceptions import CircularDependencyError
+from sqlproof.schema.model import Table
+
+
+def insertion_order(tables: tuple[Table, ...]) -> tuple[Table, ...]:
+    by_name = {table.name: table for table in tables}
+    dependents: dict[str, set[str]] = defaultdict(set)
+    indegree = {table.name: 0 for table in tables}
+
+    for table in tables:
+        dependencies = {
+            fk.referenced_table
+            for fk in table.foreign_keys
+            if fk.referenced_table != table.name and fk.referenced_table in by_name
+        }
+        indegree[table.name] = len(dependencies)
+        for dependency in dependencies:
+            dependents[dependency].add(table.name)
+
+    ready = deque(table.name for table in tables if indegree[table.name] == 0)
+    ordered: list[Table] = []
+    while ready:
+        name = ready.popleft()
+        ordered.append(by_name[name])
+        for dependent in sorted(dependents[name]):
+            indegree[dependent] -= 1
+            if indegree[dependent] == 0:
+                ready.append(dependent)
+
+    if len(ordered) != len(tables):
+        cycle = ", ".join(sorted(name for name, degree in indegree.items() if degree > 0))
+        raise CircularDependencyError(f"Circular foreign-key dependency detected: {cycle}")
+
+    return tuple(ordered)

sqlproof/schema/fingerprint.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, is_dataclass
+from typing import Any, cast
+
+from sqlproof.schema.model import SchemaInfo
+
+
+def _canonical(value: Any) -> Any:
+    if is_dataclass(value):
+        return _canonical(asdict(cast(Any, value)))
+    if isinstance(value, dict):
+        items = cast("dict[str, Any]", value)
+        return {key: _canonical(items[key]) for key in sorted(items)}
+    if isinstance(value, tuple):
+        tuple_value = cast("tuple[Any, ...]", value)  # type: ignore[redundant-cast]
+        return [_canonical(item) for item in tuple_value]
+    if isinstance(value, list):
+        list_value = cast("list[Any]", value)  # type: ignore[redundant-cast]
+        return [_canonical(item) for item in list_value]
+    return value
+
+
+def compute(schema_info: SchemaInfo) -> str:
+    canonical_json = json.dumps(
+        _canonical(schema_info),
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=True,
+    )
+    digest = hashlib.sha256(canonical_json.encode("utf-8")).hexdigest()
+    return f"sha256:{digest}"

sqlproof/schema/introspect.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+from typing import Any, Literal, cast
+
+from sqlproof.schema.model import CheckConstraint, Column, ForeignKey, PgType, SchemaInfo, Table
+
+
+def introspect_schema(connection: Any, *, schema: str = "public") -> SchemaInfo:
+    enums = _load_enums(connection, schema=schema)
+    enum_by_name = {enum.name: enum for enum in enums}
+    columns_by_table: dict[tuple[str, str], list[Column]] = {}
+    for row in _fetch_all(connection, _COLUMNS_SQL, schema):
+        key = (str(row["schema_name"]), str(row["table_name"]))
+        type_name = str(row["type_name"])
+        pg_type = enum_by_name.get(type_name, PgType(kind="scalar", name=type_name))
+        columns_by_table.setdefault(key, []).append(
+            Column(
+                name=str(row["column_name"]),
+                type=pg_type,
+                nullable=bool(row["nullable"]),
+                default=_optional_str(row["default"]),
+                is_generated=bool(row["is_generated"]) or _is_serial_default(row["default"]),
+                identity=_identity(row["identity"]),
+            )
+        )
+
+    primary_keys = _constraint_columns(connection, _PRIMARY_KEYS_SQL, schema)
+    unique_constraints = _grouped_constraints(connection, _UNIQUES_SQL, schema)
+    foreign_keys = _foreign_keys(connection, schema=schema)
+    check_constraints = _check_constraints(connection, schema=schema)
+
+    tables = [
+        Table(
+            schema=table_schema,
+            name=table_name,
+            columns=tuple(columns),
+            primary_key=primary_keys.get((table_schema, table_name), ()),
+            foreign_keys=tuple(foreign_keys.get((table_schema, table_name), ())),
+            unique_constraints=tuple(unique_constraints.get((table_schema, table_name), ())),
+            check_constraints=tuple(check_constraints.get((table_schema, table_name), ())),
+        )
+        for (table_schema, table_name), columns in sorted(columns_by_table.items())
+    ]
+    return SchemaInfo(tables=tuple(tables), enums=enums)
+
+
+def _fetch_all(connection: Any, sql: str, *params: object) -> list[dict[str, Any]]:
+    cursor = connection.execute(sql, params)
+    return [dict(row) for row in cursor.fetchall()]
+
+
+def _load_enums(connection: Any, *, schema: str) -> tuple[PgType, ...]:
+    rows = _fetch_all(connection, _ENUMS_SQL, schema)
+    return tuple(
+        PgType(
+            kind="enum",
+            name=str(row["enum_name"]),
+            enum_values=tuple(str(value) for value in row["enum_values"]),
+        )
+        for row in rows
+    )
+
+
+def _constraint_columns(
+    connection: Any, sql: str, schema: str
+) -> dict[tuple[str, str], tuple[str, ...]]:
+    return {
+        (str(row["schema_name"]), str(row["table_name"])): tuple(
+            str(value) for value in row["columns"]
+        )
+        for row in _fetch_all(connection, sql, schema)
+    }
+
+
+def _grouped_constraints(
+    connection: Any, sql: str, schema: str
+) -> dict[tuple[str, str], list[tuple[str, ...]]]:
+    grouped: dict[tuple[str, str], list[tuple[str, ...]]] = {}
+    for row in _fetch_all(connection, sql, schema):
+        key = (str(row["schema_name"]), str(row["table_name"]))
+        grouped.setdefault(key, []).append(tuple(str(value) for value in row["columns"]))
+    return grouped
+
+
+def _foreign_keys(connection: Any, *, schema: str) -> dict[tuple[str, str], list[ForeignKey]]:
+    grouped: dict[tuple[str, str], list[ForeignKey]] = {}
+    for row in _fetch_all(connection, _FOREIGN_KEYS_SQL, schema):
+        key = (str(row["schema_name"]), str(row["table_name"]))
+        grouped.setdefault(key, []).append(
+            ForeignKey(
+                columns=tuple(str(value) for value in row["columns"]),
+                referenced_table=str(row["referenced_table"]),
+                referenced_columns=tuple(str(value) for value in row["referenced_columns"]),
+                on_delete=cast(
+                    Literal["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"],
+                    str(row["on_delete"]),
+                ),
+                on_update=cast(
+                    Literal["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"],
+                    str(row["on_update"]),
+                ),
+                referenced_schema=str(row["referenced_schema"]),
+            )
+        )
+    return grouped
+
+
+def _check_constraints(
+    connection: Any, *, schema: str
+) -> dict[tuple[str, str], list[CheckConstraint]]:
+    grouped: dict[tuple[str, str], list[CheckConstraint]] = {}
+    for row in _fetch_all(connection, _CHECKS_SQL, schema):
+        key = (str(row["schema_name"]), str(row["table_name"]))
+        grouped.setdefault(key, []).append(CheckConstraint(str(row["expression"])))
+    return grouped
+
+
+def _optional_str(value: object) -> str | None:
+    return None if value is None else str(value)
+
+
+def _identity(value: object) -> Literal["always", "by_default"] | None:
+    if value is None:
+        return None
+    normalized = str(value).lower().replace(" ", "_")
+    if normalized in {"always", "by_default"}:
+        return cast(Literal["always", "by_default"], normalized)
+    return None
+
+
+def _is_serial_default(value: object) -> bool:
+    return isinstance(value, str) and value.startswith("nextval(")
+
+
+_ENUMS_SQL = """
+SELECT
+  n.nspname AS schema_name,
+  t.typname AS enum_name,
+  array_agg(e.enumlabel ORDER BY e.enumsortorder) AS enum_values
+FROM pg_catalog.pg_type t
+JOIN pg_catalog.pg_enum e ON e.enumtypid = t.oid
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+WHERE n.nspname = %s
+GROUP BY n.nspname, t.typname
+ORDER BY n.nspname, t.typname
+"""
+
+_COLUMNS_SQL = """
+SELECT
+  ns.nspname AS schema_name,
+  cls.relname AS table_name,
+  att.attname AS column_name,
+  typ.typname AS type_name,
+  NOT att.attnotnull AS nullable,
+  pg_get_expr(def.adbin, def.adrelid) AS default,
+  att.attgenerated <> '' AS is_generated,
+  CASE att.attidentity WHEN 'a' THEN 'always' WHEN 'd' THEN 'by default' ELSE NULL END AS identity,
+  ARRAY[]::integer[] AS modifiers
+FROM pg_catalog.pg_attribute att
+JOIN pg_catalog.pg_class cls ON cls.oid = att.attrelid
+JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+JOIN pg_catalog.pg_type typ ON typ.oid = att.atttypid
+LEFT JOIN pg_catalog.pg_attrdef def ON def.adrelid = att.attrelid AND def.adnum = att.attnum
+WHERE ns.nspname = %s
+  AND cls.relkind IN ('r', 'p')
+  AND att.attnum > 0
+  AND NOT att.attisdropped
+ORDER BY ns.nspname, cls.relname, att.attnum
+"""
+
+_PRIMARY_KEYS_SQL = """
+SELECT
+  ns.nspname AS schema_name,
+  cls.relname AS table_name,
+  array_agg(att.attname ORDER BY key_column.ordinality) AS columns
+FROM pg_catalog.pg_constraint con
+JOIN pg_catalog.pg_class cls ON cls.oid = con.conrelid
+JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+JOIN unnest(con.conkey) WITH ORDINALITY AS key_column(attnum, ordinality) ON true
+JOIN pg_catalog.pg_attribute att ON att.attrelid = cls.oid AND att.attnum = key_column.attnum
+WHERE ns.nspname = %s AND con.contype = 'p'
+GROUP BY ns.nspname, cls.relname, con.oid
+"""
+
+_UNIQUES_SQL = _PRIMARY_KEYS_SQL.replace("con.contype = 'p'", "con.contype = 'u'")
+
+_FOREIGN_KEYS_SQL = """
+SELECT
+  ns.nspname AS schema_name,
+  cls.relname AS table_name,
+  array_agg(src_att.attname ORDER BY src_key.ordinality) AS columns,
+  ref_ns.nspname AS referenced_schema,
+  ref_cls.relname AS referenced_table,
+  array_agg(ref_att.attname ORDER BY ref_key.ordinality) AS referenced_columns,
+  CASE con.confdeltype
+    WHEN 'r' THEN 'RESTRICT' WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL'
+    WHEN 'd' THEN 'SET DEFAULT' ELSE 'NO ACTION'
+  END AS on_delete,
+  CASE con.confupdtype
+    WHEN 'r' THEN 'RESTRICT' WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL'
+    WHEN 'd' THEN 'SET DEFAULT' ELSE 'NO ACTION'
+  END AS on_update
+FROM pg_catalog.pg_constraint con
+JOIN pg_catalog.pg_class cls ON cls.oid = con.conrelid
+JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+JOIN pg_catalog.pg_class ref_cls ON ref_cls.oid = con.confrelid
+JOIN pg_catalog.pg_namespace ref_ns ON ref_ns.oid = ref_cls.relnamespace
+JOIN unnest(con.conkey) WITH ORDINALITY AS src_key(attnum, ordinality) ON true
+JOIN unnest(con.confkey) WITH ORDINALITY AS ref_key(attnum, ordinality)
+  ON ref_key.ordinality = src_key.ordinality
+JOIN pg_catalog.pg_attribute src_att
+  ON src_att.attrelid = cls.oid AND src_att.attnum = src_key.attnum
+JOIN pg_catalog.pg_attribute ref_att
+  ON ref_att.attrelid = ref_cls.oid AND ref_att.attnum = ref_key.attnum
+WHERE ns.nspname = %s AND con.contype = 'f'
+GROUP BY ns.nspname, cls.relname, ref_ns.nspname, ref_cls.relname, con.oid
+"""
+
+_CHECKS_SQL = """
+SELECT
+  ns.nspname AS schema_name,
+  cls.relname AS table_name,
+  pg_get_constraintdef(con.oid, true) AS expression
+FROM pg_catalog.pg_constraint con
+JOIN pg_catalog.pg_class cls ON cls.oid = con.conrelid
+JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+WHERE ns.nspname = %s AND con.contype = 'c'
+ORDER BY ns.nspname, cls.relname, con.conname
+"""

sqlproof/schema/model.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from sqlproof.exceptions import SqlProofSchemaError
+
+
+@dataclass(frozen=True, slots=True)
+class PgType:
+    kind: Literal["scalar", "array", "enum", "domain", "composite", "range"]
+    name: str
+    base: PgType | None = None
+    enum_values: tuple[str, ...] = ()
+    array_dim: int = 0
+    modifiers: tuple[int, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedCheck:
+    kind: Literal["range", "in_set", "regex", "length", "compound"]
+    column: str
+    payload: Any
+
+
+@dataclass(frozen=True, slots=True)
+class CheckConstraint:
+    expression: str
+    parsed: ParsedCheck | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Column:
+    name: str
+    type: PgType
+    nullable: bool
+    default: str | None
+    is_generated: bool
+    identity: Literal["always", "by_default"] | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ForeignKey:
+    columns: tuple[str, ...]
+    referenced_table: str
+    referenced_columns: tuple[str, ...]
+    on_delete: Literal["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"]
+    on_update: Literal["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"]
+    referenced_schema: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Table:
+    schema: str
+    name: str
+    columns: tuple[Column, ...]
+    primary_key: tuple[str, ...]
+    foreign_keys: tuple[ForeignKey, ...]
+    unique_constraints: tuple[tuple[str, ...], ...]
+    check_constraints: tuple[CheckConstraint, ...]
+    opaque_constraints: tuple[str, ...] = ()
+
+    @property
+    def qualified_name(self) -> str:
+        return f"{self.schema}.{self.name}"
+
+    def column(self, name: str) -> Column:
+        for column in self.columns:
+            if column.name == name:
+                return column
+        msg = f"Unknown column {name!r} on table {self.qualified_name!r}."
+        raise SqlProofSchemaError(msg)
+
+
+@dataclass(frozen=True, slots=True)
+class Function:
+    schema: str
+    name: str
+    arg_types: tuple[PgType, ...]
+    return_type: PgType
+    volatility: Literal["immutable", "stable", "volatile"]
+    language: str
+
+
+@dataclass(frozen=True, slots=True)
+class SchemaInfo:
+    tables: tuple[Table, ...] = ()
+    enums: tuple[PgType, ...] = ()
+    functions: tuple[Function, ...] = ()
+    domains: tuple[PgType, ...] = ()
+    opaque_sql: tuple[str, ...] = field(default_factory=tuple)
+
+    def table(self, name: str, schema: str = "public") -> Table:
+        for table in self.tables:
+            if table.name == name and table.schema == schema:
+                return table
+        msg = f"Unknown table {schema}.{name}."
+        raise SqlProofSchemaError(msg)