sqlassert 0.1.0__py3-none-any.whl

sqlassert/__init__.py

@@ -0,0 +1,13 @@
+from sqlassert.unique import (
+    UniqueJoinCheckResult,
+    UniqueJoinValidationResult,
+    unique_assertions,
+    validate_unique_joins,
+)
+
+__all__ = [
+    "UniqueJoinCheckResult",
+    "UniqueJoinValidationResult",
+    "unique_assertions",
+    "validate_unique_joins",
+]

sqlassert/unique.py

@@ -0,0 +1,605 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Any
+
+import sqlglot
+from sqlglot import exp
+from sqlglot.errors import SqlglotError
+from sqlglot.tokens import TokenType, Tokenizer
+
+
+FALSE_ASSERTION = "select false"
+MARKER = re.compile(re.escape(r"/**unique**/"), flags=re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class UniqueJoinCheckResult:
+    marker_index: int
+    valid: bool
+    reason: str
+    inferred_key_columns: tuple[str, ...] = ()
+    constrained_key_columns: tuple[str, ...] = ()
+    unique_constraints: tuple[tuple[str, ...], ...] = ()
+
+
+@dataclass(frozen=True)
+class UniqueJoinValidationResult:
+    valid: bool
+    reason: str
+    checks: tuple[UniqueJoinCheckResult, ...] = ()
+
+
+@dataclass(frozen=True)
+class _UniqueJoinPlan:
+    marker_index: int
+    reason: str
+    join_sql: str = ""
+    rhs: exp.Expression | None = None
+    rhs_names: frozenset[str] = frozenset()
+    keys: tuple[exp.Column, ...] = ()
+    rhs_filter_columns: tuple[exp.Column, ...] = ()
+
+
+def validate_unique_joins(
+    connection: Any,
+    sql: str,
+    dialect: str = "duckdb",
+) -> UniqueJoinValidationResult:
+    plans = _unique_join_plans(sql, dialect)
+    if not plans:
+        return UniqueJoinValidationResult(True, "no unique join markers found")
+
+    checks = tuple(_validate_plan(connection, plan) for plan in plans)
+    if all(check.valid for check in checks):
+        return UniqueJoinValidationResult(True, "all unique join assertions passed", checks)
+
+    reason = "; ".join(check.reason for check in checks if not check.valid)
+    return UniqueJoinValidationResult(False, reason, checks)
+
+
+def unique_assertions(sql: str, dialect: str = "duckdb") -> list[str]:
+    return [FALSE_ASSERTION for _ in _unique_join_plans(sql, dialect)]
+
+
+def _unique_join_plans(sql: str, dialect: str) -> list[_UniqueJoinPlan]:
+    marker_join_indexes = _marked_join_indexes(sql, dialect)
+    if not marker_join_indexes:
+        return []
+
+    try:
+        expressions = [expression for expression in sqlglot.parse(sql, read=dialect) if expression]
+    except SqlglotError:
+        return [
+            _UniqueJoinPlan(index, "SQL parse failed")
+            for index, _ in enumerate(marker_join_indexes)
+        ]
+
+    joins: list[exp.Join] = []
+    for expression in expressions:
+        joins.extend(expression.find_all(exp.Join))
+
+    plans: list[_UniqueJoinPlan] = []
+    for marker_index, join_index in enumerate(marker_join_indexes):
+        if join_index is None or join_index >= len(joins):
+            plans.append(_UniqueJoinPlan(marker_index, "marker is not followed by a join"))
+            continue
+        plans.append(_plan_for_join(marker_index, joins[join_index], dialect))
+    return plans
+
+
+def _marked_join_indexes(sql: str, dialect: str) -> list[int | None]:
+    marker_offsets = [match.end() for match in MARKER.finditer(sql)]
+    if not marker_offsets:
+        return []
+
+    tokens = Tokenizer(dialect=dialect).tokenize(sql)
+    join_offsets = [
+        token.start
+        for token in tokens
+        if token.token_type is TokenType.JOIN
+    ]
+
+    indexes: list[int | None] = []
+    for marker_offset in marker_offsets:
+        next_join_index = next(
+            (index for index, join_offset in enumerate(join_offsets) if join_offset >= marker_offset),
+            None,
+        )
+        indexes.append(next_join_index)
+    return indexes
+
+
+def _plan_for_join(marker_index: int, join: exp.Join, dialect: str) -> _UniqueJoinPlan:
+    join_sql = _join_sql(join, dialect)
+    kind = (join.args.get("kind") or "").upper()
+    if kind in {"ANTI", "SEMI"}:
+        return _UniqueJoinPlan(
+            marker_index,
+            f'{_join_reason_prefix(join_sql)}, {kind.lower()} joins are not supported',
+            join_sql,
+        )
+
+    rhs = join.this
+    on = join.args.get("on")
+    using = join.args.get("using") or []
+    if rhs is None:
+        return _UniqueJoinPlan(marker_index, f"{_join_reason_prefix(join_sql)}, marked join has no RHS relation", join_sql)
+    if on is None and not using:
+        return _UniqueJoinPlan(marker_index, f"{_join_reason_prefix(join_sql)}, marked join has no ON or USING predicate", join_sql)
+
+    rhs_names = _rhs_names(rhs)
+    if not rhs_names:
+        return _UniqueJoinPlan(
+            marker_index,
+            f"{_join_reason_prefix(join_sql)}, could not identify RHS relation name or alias",
+            join_sql,
+        )
+
+    keys = _rhs_using_columns(using) if using else _rhs_key_columns(on, rhs_names)
+    if not keys:
+        return _UniqueJoinPlan(
+            marker_index,
+            f"{_join_reason_prefix(join_sql)}, could not infer RHS key columns from join predicate",
+            join_sql,
+        )
+
+    return _UniqueJoinPlan(
+        marker_index=marker_index,
+        reason="join predicate inferred",
+        join_sql=join_sql,
+        rhs=rhs,
+        rhs_names=frozenset(rhs_names),
+        keys=tuple(keys),
+        rhs_filter_columns=tuple(_rhs_filter_columns(on, rhs_names) if on is not None else ()),
+    )
+
+
+def _validate_plan(connection: Any, plan: _UniqueJoinPlan) -> UniqueJoinCheckResult:
+    key_names = tuple(key.name for key in plan.keys)
+    if plan.rhs is None or not plan.keys:
+        return UniqueJoinCheckResult(
+            marker_index=plan.marker_index,
+            valid=False,
+            reason=plan.reason,
+            inferred_key_columns=key_names,
+        )
+
+    unique_constraints = _relation_unique_constraints(connection, plan.rhs)
+    if not unique_constraints:
+        return UniqueJoinCheckResult(
+            marker_index=plan.marker_index,
+            valid=False,
+            reason=_cannot_prove_reason(plan),
+            inferred_key_columns=key_names,
+            unique_constraints=unique_constraints,
+        )
+
+    constraint_check = _validate_constraints(plan, key_names, unique_constraints)
+    if constraint_check is not None:
+        return constraint_check
+
+    return UniqueJoinCheckResult(
+        marker_index=plan.marker_index,
+        valid=False,
+        reason=_cannot_prove_reason(plan),
+        inferred_key_columns=key_names,
+        unique_constraints=unique_constraints,
+    )
+
+
+def _validate_constraints(
+    plan: _UniqueJoinPlan,
+    key_names: tuple[str, ...],
+    unique_constraints: tuple[tuple[str, ...], ...],
+) -> UniqueJoinCheckResult | None:
+    covered_columns = _covered_rhs_column_names(plan)
+    for constraint in unique_constraints:
+        if all(column.lower() in covered_columns for column in constraint):
+            constrained_key_columns = tuple(constraint)
+            return UniqueJoinCheckResult(
+                marker_index=plan.marker_index,
+                valid=True,
+                reason=(
+                    f"RHS uniqueness proof ({', '.join(constrained_key_columns)}) "
+                    "is covered by inferred keys/filters "
+                    f"({', '.join(sorted(covered_columns))})"
+                ),
+                inferred_key_columns=key_names,
+                constrained_key_columns=constrained_key_columns,
+                unique_constraints=unique_constraints,
+            )
+    return None
+
+
+def _cannot_prove_reason(plan: _UniqueJoinPlan) -> str:
+    rhs_columns = _format_columns(tuple(key.name for key in plan.keys))
+    verb = "is" if len(plan.keys) == 1 else "are"
+    return f"{_join_reason_prefix(plan.join_sql)}, we can't prove that RHS {rhs_columns} {verb} unique"
+
+
+def _join_reason_prefix(join_sql: str) -> str:
+    return f'in join: "{join_sql}"'
+
+
+def _join_sql(join: exp.Join, dialect: str) -> str:
+    join_sql = join.sql(dialect=dialect)
+    join_sql = re.sub(r"/\*\s*\*?\s*unique\s*\*?\s*\*/", "", join_sql, flags=re.IGNORECASE)
+    return " ".join(join_sql.split())
+
+
+def _rhs_names(rhs: exp.Expression) -> set[str]:
+    if rhs.alias:
+        return {rhs.alias.lower()}
+    if isinstance(rhs, exp.Table):
+        return {rhs.name.lower()}
+    if rhs.alias_or_name:
+        return {rhs.alias_or_name.lower()}
+    return set()
+
+
+def _rhs_key_columns(on: exp.Expression, rhs_names: set[str]) -> list[exp.Column]:
+    keys: list[exp.Column] = []
+    seen: set[tuple[str, str]] = set()
+
+    for equality in on.find_all(exp.EQ):
+        rhs_column = _simple_rhs_column(equality.this, equality.expression, rhs_names)
+        if rhs_column is None:
+            rhs_column = _simple_rhs_column(equality.expression, equality.this, rhs_names)
+        if rhs_column is None:
+            continue
+
+        key = (_column_table(rhs_column).lower(), rhs_column.name.lower())
+        if key not in seen:
+            keys.append(rhs_column.copy())
+            seen.add(key)
+
+    return keys
+
+
+def _rhs_using_columns(using: list[exp.Identifier]) -> list[exp.Column]:
+    keys = []
+    seen = set()
+    for identifier in using:
+        name = identifier.name
+        if name.lower() in seen:
+            continue
+        keys.append(exp.column(name))
+        seen.add(name.lower())
+    return keys
+
+
+def _simple_rhs_column(
+    maybe_column: exp.Expression,
+    other_side: exp.Expression,
+    rhs_names: set[str],
+) -> exp.Column | None:
+    if not isinstance(maybe_column, exp.Column):
+        return None
+    if not _is_rhs_column(maybe_column, rhs_names):
+        return None
+    if any(_is_rhs_column(column, rhs_names) for column in other_side.find_all(exp.Column)):
+        return None
+    return maybe_column
+
+
+def _rhs_filter_columns(on: exp.Expression, rhs_names: set[str]) -> list[exp.Column]:
+    filters: list[exp.Column] = []
+    seen: set[tuple[str, str]] = set()
+
+    for predicate in _and_terms(on):
+        columns = list(predicate.find_all(exp.Column))
+        if not columns or not all(_is_rhs_column(column, rhs_names) for column in columns):
+            continue
+        for column in columns:
+            key = (_column_table(column).lower(), column.name.lower())
+            if key not in seen:
+                filters.append(column.copy())
+                seen.add(key)
+
+    return filters
+
+
+def _and_terms(expression: exp.Expression) -> Iterable[exp.Expression]:
+    if isinstance(expression, exp.And):
+        yield from _and_terms(expression.this)
+        yield from _and_terms(expression.expression)
+    else:
+        yield expression
+
+
+def _is_rhs_column(column: exp.Column, rhs_names: set[str]) -> bool:
+    table = _column_table(column)
+    return bool(table and table.lower() in rhs_names)
+
+
+def _column_table(column: exp.Column) -> str:
+    table = column.table
+    return table if isinstance(table, str) else ""
+
+
+def _covered_rhs_column_names(plan: _UniqueJoinPlan) -> set[str]:
+    return {
+        column.name.lower()
+        for column in (*plan.keys, *plan.rhs_filter_columns)
+    }
+
+
+def _relation_unique_constraints(
+    connection: Any,
+    relation: exp.Expression,
+    seen_views: frozenset[tuple[str, str]] = frozenset(),
+) -> tuple[tuple[str, ...], ...]:
+    if isinstance(relation, exp.Table):
+        constraints = _unique_constraints(connection, relation)
+        if constraints:
+            return constraints
+        return _view_unique_constraints(connection, relation, seen_views)
+
+    if isinstance(relation, exp.Subquery) and isinstance(relation.this, exp.Select):
+        return _select_unique_constraints(connection, relation.this, seen_views)
+
+    return ()
+
+
+def _view_unique_constraints(
+    connection: Any,
+    view: exp.Table,
+    seen_views: frozenset[tuple[str, str]],
+) -> tuple[tuple[str, ...], ...]:
+    schema_name = _table_schema(view) or "main"
+    view_key = (schema_name.lower(), view.name.lower())
+    if view_key in seen_views:
+        return ()
+
+    view_sql = _view_sql(connection, view)
+    if not view_sql:
+        return ()
+
+    try:
+        expression = sqlglot.parse_one(view_sql, read="duckdb")
+    except SqlglotError:
+        return ()
+
+    if not isinstance(expression, exp.Create) or not isinstance(expression.expression, exp.Select):
+        return ()
+
+    return _select_unique_constraints(connection, expression.expression, seen_views | {view_key})
+
+
+def _view_sql(connection: Any, view: exp.Table) -> str:
+    schema_name = _table_schema(view)
+    if schema_name:
+        query = (
+            "select sql "
+            "from duckdb_views() "
+            "where view_name = ? "
+            "and schema_name = ? "
+            "and not internal "
+            "order by database_name, schema_name "
+            "limit 1"
+        )
+        params = (view.name, schema_name)
+    else:
+        query = (
+            "select sql "
+            "from duckdb_views() "
+            "where view_name = ? "
+            "and not internal "
+            "order by database_name, schema_name "
+            "limit 1"
+        )
+        params = (view.name,)
+
+    try:
+        row = connection.execute(query, params).fetchone()
+    except Exception:
+        return ""
+
+    return row[0] if row else ""
+
+
+def _select_unique_constraints(
+    connection: Any,
+    select: exp.Select,
+    seen_views: frozenset[tuple[str, str]],
+) -> tuple[tuple[str, ...], ...]:
+    constraints = []
+    group_constraint = _group_by_constraint(select)
+    if group_constraint:
+        constraints.append(group_constraint)
+
+    distinct_constraint = _distinct_constraint(select)
+    if distinct_constraint:
+        constraints.append(distinct_constraint)
+
+    qualify_constraint = _qualify_row_number_constraint(select)
+    if qualify_constraint:
+        constraints.append(qualify_constraint)
+
+    constraints.extend(_projected_source_constraints(connection, select, seen_views))
+
+    return _dedupe_constraints(tuple(constraints))
+
+
+def _projected_source_constraints(
+    connection: Any,
+    select: exp.Select,
+    seen_views: frozenset[tuple[str, str]],
+) -> tuple[tuple[str, ...], ...]:
+    source = _single_select_source(select)
+    if source is None:
+        return ()
+
+    source_constraints = _relation_unique_constraints(connection, source, seen_views)
+    if not source_constraints:
+        return ()
+
+    projection = _projection_map(select.expressions)
+    if not projection:
+        return ()
+
+    constraints = []
+    for constraint in source_constraints:
+        mapped = []
+        for column in constraint:
+            output_name = projection.get(column.lower())
+            if output_name is None:
+                break
+            mapped.append(output_name)
+        else:
+            constraints.append(tuple(mapped))
+
+    return tuple(constraints)
+
+
+def _single_select_source(select: exp.Select) -> exp.Expression | None:
+    if select.args.get("joins"):
+        return None
+
+    from_ = select.args.get("from_")
+    if not isinstance(from_, exp.From):
+        return None
+
+    source = from_.this
+    if isinstance(source, exp.Table | exp.Subquery):
+        return source
+    return None
+
+
+def _projection_map(expressions: list[exp.Expression]) -> dict[str, str]:
+    projection: dict[str, str] = {}
+    for expression in expressions:
+        source_name, output_name = _projection_column_names(expression)
+        if source_name and output_name and source_name.lower() not in projection:
+            projection[source_name.lower()] = output_name
+    return projection
+
+
+def _projection_column_names(expression: exp.Expression) -> tuple[str, str]:
+    if isinstance(expression, exp.Alias) and isinstance(expression.this, exp.Column):
+        return expression.this.name, expression.alias
+    if isinstance(expression, exp.Column):
+        return expression.name, expression.name
+    return "", ""
+
+
+def _dedupe_constraints(constraints: tuple[tuple[str, ...], ...]) -> tuple[tuple[str, ...], ...]:
+    deduped = []
+    seen = set()
+    for constraint in constraints:
+        key = tuple(column.lower() for column in constraint)
+        if key in seen:
+            continue
+        deduped.append(constraint)
+        seen.add(key)
+    return tuple(deduped)
+
+
+def _group_by_constraint(select: exp.Select) -> tuple[str, ...]:
+    group = select.args.get("group")
+    if not isinstance(group, exp.Group):
+        return ()
+    return _simple_output_columns(group.expressions)
+
+
+def _distinct_constraint(select: exp.Select) -> tuple[str, ...]:
+    if select.args.get("distinct") is None:
+        return ()
+    return _simple_output_columns(select.expressions)
+
+
+def _qualify_row_number_constraint(select: exp.Select) -> tuple[str, ...]:
+    qualify = select.args.get("qualify")
+    if not isinstance(qualify, exp.Qualify):
+        return ()
+
+    window = _row_number_window_filtered_to_one(qualify.this)
+    if window is None:
+        return ()
+    return _simple_output_columns(window.args.get("partition_by") or [])
+
+
+def _row_number_window_filtered_to_one(expression: exp.Expression) -> exp.Window | None:
+    if not isinstance(expression, exp.EQ):
+        return None
+
+    if _is_row_number_window(expression.this) and _is_one(expression.expression):
+        return expression.this
+    if _is_row_number_window(expression.expression) and _is_one(expression.this):
+        return expression.expression
+    return None
+
+
+def _is_row_number_window(expression: exp.Expression) -> bool:
+    return isinstance(expression, exp.Window) and isinstance(expression.this, exp.RowNumber)
+
+
+def _is_one(expression: exp.Expression) -> bool:
+    return isinstance(expression, exp.Literal) and not expression.is_string and expression.this == "1"
+
+
+def _simple_output_columns(expressions: Iterable[exp.Expression]) -> tuple[str, ...]:
+    columns = []
+    seen = set()
+    for expression in expressions:
+        name = _simple_output_column_name(expression)
+        if name and name.lower() not in seen:
+            columns.append(name)
+            seen.add(name.lower())
+    return tuple(columns)
+
+
+def _simple_output_column_name(expression: exp.Expression) -> str:
+    if isinstance(expression, exp.Alias):
+        return expression.alias
+    if isinstance(expression, exp.Column):
+        return expression.name
+    return ""
+
+
+def _unique_constraints(connection: Any, rhs: exp.Table) -> tuple[tuple[str, ...], ...]:
+    schema_name = _table_schema(rhs)
+    if schema_name:
+        query = (
+            "select constraint_column_names "
+            "from duckdb_constraints() "
+            "where table_name = ? "
+            "and schema_name = ? "
+            "and constraint_type in ('PRIMARY KEY', 'UNIQUE') "
+            "order by constraint_index"
+        )
+        params = (rhs.name, schema_name)
+    else:
+        query = (
+            "select constraint_column_names "
+            "from duckdb_constraints() "
+            "where table_name = ? "
+            "and constraint_type in ('PRIMARY KEY', 'UNIQUE') "
+            "order by constraint_index"
+        )
+        params = (rhs.name,)
+
+    try:
+        rows = connection.execute(query, params).fetchall()
+    except Exception:
+        return ()
+
+    return tuple(tuple(row[0]) for row in rows)
+
+
+def _table_schema(table: exp.Table) -> str:
+    db = table.args.get("db")
+    if isinstance(db, exp.Identifier):
+        return db.name
+    if isinstance(db, str):
+        return db
+    return ""
+
+
+def _format_columns(columns: tuple[str, ...]) -> str:
+    if len(columns) == 1:
+        return f"column {columns[0]}"
+    return f"columns {', '.join(columns)}"

sqlassert-0.1.0.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: sqlassert
+Version: 0.1.0
+Summary: Generate SQL assertions from unique join markers.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: sqlglot>=28
+Provides-Extra: test
+Requires-Dist: duckdb; extra == "test"
+Requires-Dist: pytest; extra == "test"
+
+# sqlassert
+
+`sqlassert` is a Python library for adding safety checks to SQL before you run it.
+
+The goal is to catch common query mistakes at test time or build time, using fast static and metadata-backed proofs instead of scanning production data. You can add `sqlassert` to your test suite and validate important queries offline, making them more resilient independent of the current contents of your database.
+
+
+```bash
+pip install sqlassert
+```
+
+_Alpha warning: Today `sqlassert` supports only one check: `/**UNIQUE**/` joins. It is also only tested on duckdb._
+
+## Features
+
+### Unique Join
+
+Joins often accidentally multiply rows. A query may look correct against today’s data but silently break when the RHS relation later contains multiple matching rows.
+
+`sqlassert` lets you mark joins that are expected to be unique. That is, the result of the join must never 'grow' the number of rows with respect to the LHS.
+
+```sql
+select *
+from sessions
+/**UNIQUE**/ join users
+  on sessions.user_id = users.id;
+```
+
+The marker is just a SQL comment. Your SQL remains valid SQL and can still run normally. `sqlassert` reads the query separately and validates that the RHS is provably unique for the join keys.
+
+## Usage
+
+Run validation offline, before your application or analytics job executes the query:
+
+```python
+import duckdb
+from sqlassert import validate_unique_joins
+
+con = duckdb.connect("warehouse.duckdb")
+
+query = """
+select *
+from sessions
+/**UNIQUE**/ join users
+  on sessions.user_id = users.id
+"""
+
+result = validate_unique_joins(con, query)
+
+assert result.valid, result.reason
+```
+
+For a test suite, keep your model/query SQL as strings or load them from files, then validate them against a db connection that has the relevant schema:
+
+```python
+def test_query_join_contract(con):
+    query = load_query("models/session_enrichment.sql")
+    result = validate_unique_joins(con, query)
+
+    assert result.valid, result.reason
+```
+
+`result.checks` contains one check per marker:
+
+```python
+for check in result.checks:
+    print(check.valid)
+    print(check.reason)
+    print(check.inferred_key_columns)
+    print(check.constrained_key_columns)
+```
+
+## Details
+
+### Unique Join Syntax
+
+Place `/**UNIQUE**/` immediately before the join that should be uniqueness-checked:
+
+```sql
+select *
+from lhs
+/**UNIQUE**/ left join rhs
+  on lhs.rhs_id = rhs.id;
+```
+
+`ON` and `USING` are both supported:
+
+```sql
+select *
+from users
+/**UNIQUE**/ join user_profiles
+  using (id);
+```
+
+The marker applies to the next join after the comment.
+
+## Proofs, Not Data Checks
+
+`sqlassert` does **not** validate by querying actual table data. It will not run `count(*)`, search for duplicates, or sample rows.
+
+Instead, it proves uniqueness using fast information available from the SQL and database metadata. If uniqueness cannot be proven, validation fails with a reason that names the join and RHS column:
+
+```text
+in join "INNER JOIN events ON sessions.event_id = events.id", we can't prove that RHS column id is unique
+```
+
+Supported uniqueness proofs today:
+
+- RHS `PRIMARY KEY` and `UNIQUE` constraints from db metadata.
+- RHS `GROUP BY` subqueries, when the join covers the grouping keys.
+- RHS `SELECT DISTINCT` subqueries, when the join covers the selected distinct columns.
+- RHS `QUALIFY row_number() over (partition by ...) = 1` subqueries, when the join covers the partition keys.
+- Simple projection views and subqueries that preserve one of the proofs above.
+
+Views can inherit uniqueness when they are simple projections over a source relation with a supported proof. Filters preserve uniqueness; computed expressions, joins inside views, unions, and arbitrary subquery semantics are not guessed.
+
+Examples:
+
+```sql
+-- Proved by primary key.
+select *
+from sessions
+/**UNIQUE**/ join users
+  on sessions.user_id = users.id;
+```
+
+```sql
+-- Proved by composite primary key plus RHS-only filter.
+select *
+from sessions
+/**UNIQUE**/ join orders
+  on sessions.user_id = orders.user_id
+ and orders.order_id = 1;
+```
+
+```sql
+-- Proved by GROUP BY.
+with latest_session as (
+  select user_id, max(ts) as max_ts
+  from sessions
+  group by user_id
+)
+select *
+from users
+/**UNIQUE**/ join latest_session
+  on users.id = latest_session.user_id;
+```
+
+```sql
+-- Proved by QUALIFY row_number() = 1.
+with sessions_ranked as (
+    select user_id, *
+    from sessions
+    qualify row_number() over (partition by user_id order by ts) = 1
+)
+select *
+from users
+/**UNIQUE**/ join sessions_ranked
+  on users.id = sessions_ranked.user_id;
+```
+
+More compile-time SQL checks can be added under the same model: explicit syntax, fast validation, and clear reasons when a proof is missing.

sqlassert-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+sqlassert/__init__.py,sha256=Sroyw8c2hVVASyOuoRvMFnyBrgDxfMomwJs8KoXEcc8,274
+sqlassert/unique.py,sha256=Uzxti-t4Hl8iIT3bPX6NZQbWbCmzAQ-SfukhLcnc76E,19160
+sqlassert-0.1.0.dist-info/METADATA,sha256=lcdR-fUctWAlwsW7h9W_ThsWslvtfzGlwiLje8Arfl4,4971
+sqlassert-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sqlassert-0.1.0.dist-info/top_level.txt,sha256=BINwf_eEiAW975zV29VyXrSnTO9G136zvJVJ2pupnLI,10
+sqlassert-0.1.0.dist-info/RECORD,,

sqlassert-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sqlassert-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlassert