89 rules, each with a single concern.

Detect PostgreSQL syntax errors.

Disallow `SELECT *` (and `<alias>.*`) so result schemas stay stable.

Require a WHERE clause on DELETE.

Require a WHERE clause on UPDATE.

Warn on DROP TABLE ... CASCADE.

Warn on TRUNCATE ... CASCADE.

Warn on CROSS JOIN.

Disallow NATURAL JOIN — join columns are implicit.

Enforce a consistent stance on `jsonb` vs `json` for column types.

Enforce a consistent stance on `GENERATED ... AS IDENTITY` vs `SERIAL` / `BIGSERIAL`.

Require a primary key on CREATE TABLE.

Enforce a consistent stance on `text` vs `varchar(n)`.

Enforce a consistent stance on `timestamptz` vs `timestamp` for wall-clock columns.

Forbid the money column type.

Avoid CHAR(n) — it pads on write and trims on read.

Avoid GRANT ... TO PUBLIC.

Enforce a consistent stance on `CONCURRENTLY` for `CREATE INDEX`.

Disallow NOT IN (subquery) — NULL handling is a trap.

Require snake_case table names.

Require snake_case column names.

Avoid implicit (comma) joins.

Require a LIMIT clause on SELECT.

Disallow positional `ORDER BY` references (e.g., `ORDER BY 1`).

Disallow positional `GROUP BY` references (e.g., `GROUP BY 1`).

Require ORDER BY alongside `SELECT DISTINCT ON (...)` so the surviving row is deterministic.

Warn on `LIKE`/`ILIKE` patterns that begin with `%`; they force sequential scans.

Error on `ADD COLUMN ... NOT NULL` without a `DEFAULT` — fails on non-empty tables.

Disallow `SELECT ... INTO target FROM ...`; prefer `CREATE TABLE AS SELECT`.

Flag `CASE WHEN x IS NULL THEN y ELSE x END` and recommend `COALESCE(x, y)`.

Disallow `HAVING` without `GROUP BY`; the predicate belongs in `WHERE`.

Disallow identifiers longer than PostgreSQL's `NAMEDATALEN - 1` limit (default 63 bytes).

Warn on `ALTER COLUMN ... TYPE` — can rewrite the table under ACCESS EXCLUSIVE.

Warn on `RENAME COLUMN` — breaks deployed code reading the old name.

Warn on `RENAME TO` — breaks deployed code reading the old name.

Warn on `DROP COLUMN` — breaks every reader still referencing the column.

Warn on `DROP NOT NULL` — surprises consumers that already assume non-null.

Enforce a consistent stance on `NOT VALID` for `ALTER TABLE ... ADD FOREIGN KEY`.

Require explicit names on CHECK / UNIQUE / FK / EXCLUSION constraints.

Warn on `CREATE UNLOGGED TABLE` — data is lost on crash and not replicated.

Warn on `CREATE TEMP / TEMPORARY TABLE` in versioned SQL.

Require an explicit precision and scale on `NUMERIC` / `DECIMAL` columns.

Disallow `TIME` / `TIMETZ` columns; they rarely model real values correctly.

Warn on `SET NOT NULL` — full scan under ACCESS EXCLUSIVE.

Disallow `SET search_path` in versioned SQL; qualify identifiers instead.

Require schema-qualified `CREATE TABLE` (off by default).

Require `NULLS FIRST/LAST` when an explicit ORDER BY direction is used.

Warn on `VACUUM FULL` — takes ACCESS EXCLUSIVE and rewrites the table.

Warn on `CLUSTER` — ACCESS EXCLUSIVE lock, and PG doesn't maintain the order.

Disallow composite (multi-column) PRIMARY KEY constraints.

Error on `DROP DATABASE` — catastrophic and belongs to an operator workflow.

Warn on `DROP SCHEMA ... CASCADE` — removes every object in the schema with no preview.

Enforce a consistent stance on `CONCURRENTLY` for `REINDEX`.

Disallow `CREATE ROLE` / `CREATE USER` in versioned SQL.

Prefer `bigint` for primary-key `id` columns; `int` overflows at 2.1B rows.

Align column definitions vertically inside `CREATE TABLE`.

Align column values vertically inside multi-row `INSERT ... VALUES`.

Disallow `x = NULL` / `x <> NULL`; use `IS NULL` / `IS NOT NULL`.

Disallow `ON DELETE CASCADE` on foreign keys.

Disallow `CREATE RULE`; it is effectively deprecated in favor of triggers and updatable views.

Disallow `SECURITY DEFINER` functions without an explicit `SET search_path`.

Disallow `"..."` around identifiers that don't need quoting.

Disallow `UPDATE` on primary-key columns (heuristic).

Disallow `UPDATE ... FROM` without a `WHERE` (Cartesian product).

Disallow `WITH RECURSIVE` without an outer `LIMIT`.

Enforce a consistent case for SQL/PL/pgSQL keywords inside PL/pgSQL bodies.

Prefer `ADD CONSTRAINT ... NOT VALID` then `VALIDATE CONSTRAINT`.

Enforce a consistent stance on the `AS` keyword before column aliases in `SELECT`.

Enforce a consistent stance on the `AS` keyword before table aliases.

Enforce a consistent stance on `x BETWEEN a AND b` vs `x >= a AND x <= b`.

Enforce a single style for type casts (`x::int` or `CAST(x AS int)`).

Enforce a consistent stance on `CREATE OR REPLACE` for `FUNCTION` / `PROCEDURE` / `VIEW`.

Prefer SQL-standard `CURRENT_TIMESTAMP` over `now()` / `LOCALTIMESTAMP`.

Enforce a consistent stance on `CONCURRENTLY` for `DROP INDEX`.

Enforce a consistent stance on the explicit `INNER` keyword in `INNER JOIN`.

Enforce a consistent stance on the explicit `OUTER` keyword in `LEFT/RIGHT/FULL OUTER JOIN`.

Prefer `x IN (a, b, c)` over `x = a OR x = b OR x = c`.

Enforce a consistent case (upper or lower) for SQL keywords.

Enforce a single style for the not-equal operator (`<>` or `!=`).

Require `IF EXISTS` on every `DROP` statement.

Require an explicit `ON DELETE` clause on every foreign-key constraint.

Require a trailing `;` after every top-level SQL statement.

Disallow `ADD CONSTRAINT CHECK` without `NOT VALID` (lock-heavy).

Disallow inline `ADD CONSTRAINT UNIQUE`; require `USING INDEX`.

Disallow `ADD COLUMN ... DEFAULT <volatile>()` (forces full table rewrite).

Disallow `GRANT ALL` (list privileges explicitly).

Prefer `EXISTS (subquery)` over `column IN (subquery)`.

Require every foreign-key constraint to include a configured set of columns.

Require every `CREATE TABLE` to include a configured set of columns.

Require an index on every foreign-key column.