@intentius/chant-lexicon-sql 0.124.31 → 0.124.33

package/dist/lint/post-synth/sqlpg114.js

@@ -0,0 +1,39 @@
+import { STORAGE_PARAMETERS } from "../../generated/postgres.js";
+import { checkOf, rangeOf, storageParams, storageTarget, targetMajor } from "./postgres-helpers.js";
+import { postgresObjects } from "./sql-helpers.js";
+/**
+ * SQLPG114: a storage parameter the object's kind does not accept at the
+ * target major (`postgresMajor` in the output).
+ *
+ * Doc: https://www.postgresql.org/docs/18/sql-createtable.html#SQL-CREATETABLE-STORAGE-PARAMETERS
+ * (and the CREATE INDEX, CREATE VIEW and CREATE MATERIALIZED VIEW pages). The
+ * server refuses an unrecognized parameter at CREATE. The accepted names and
+ * the relation kinds they apply to come from the generated catalog, whose
+ * since/until data says which majors have each one: a parameter removed
+ * before the target major is reported as removed.
+ */
+export const sqlpg114 = checkOf({ id: "SQLPG114", description: "A storage parameter the object's kind or the target major does not accept" }, (ctx, report) => {
+    const major = targetMajor(ctx);
+    const specs = STORAGE_PARAMETERS;
+    for (const o of postgresObjects(ctx)) {
+        const target = storageTarget(o);
+        if (!target)
+            continue;
+        for (const raw of storageParams(o.with).keys()) {
+            if (raw.startsWith("toast."))
+                continue;
+            const spec = specs[raw];
+            if (!spec) {
+                report({ severity: "error", message: `${o.export} (${o.sqlName}) sets ${raw}, which is not a Postgres ${major} storage parameter`, entity: o.export });
+                continue;
+            }
+            const range = rangeOf("storageParameters", `${target}.${raw}`);
+            if (!spec.targets.includes(target)) {
+                report({ severity: "error", message: `${o.export} (${o.sqlName}) sets ${raw}, which applies to ${spec.targets.join(", ")} and not to a ${target}`, entity: o.export });
+            }
+            else if (range?.until !== undefined && range.until < major) {
+                report({ severity: "error", message: `${o.export} (${o.sqlName}) sets ${raw}, which Postgres removed after ${range.until}`, entity: o.export });
+            }
+        }
+    }
+});

package/dist/lint/post-synth/sqlpg115.js

@@ -0,0 +1,48 @@
+import { checkOf, rangeOf, storageParams, storageTarget, tablesOf, targetMajor } from "./postgres-helpers.js";
+import { indexesOf } from "./postgres-helpers.js";
+import { postgresObjects } from "./sql-helpers.js";
+/**
+ * SQLPG115: a feature newer than the target major.
+ *
+ * Doc: https://www.postgresql.org/docs/18/release-18.html (NOT ENFORCED
+ * constraints and virtual generated columns arrive in 18),
+ * https://www.postgresql.org/docs/15/release-15.html (NULLS NOT DISTINCT). Storage parameters read the generated catalog's
+ * `since` data. The target is `sql.postgresMajor`
+ * (recorded as `postgresMajor` in the output), else the newest pinned major;
+ * a feature is reported as a warning only when it is newer than the target,
+ * naming the first major that has it.
+ */
+export const sqlpg115 = checkOf({ id: "SQLPG115", description: "A feature newer than the target major" }, (ctx, report) => {
+    const major = targetMajor(ctx);
+    const note = (entity, what, since) => report({ severity: "warning", message: `${entity} uses ${what}, which needs Postgres ${since}; Postgres ${major} refuses it`, entity });
+    for (const o of postgresObjects(ctx)) {
+        const target = storageTarget(o);
+        if (!target)
+            continue;
+        for (const name of storageParams(o.with).keys()) {
+            // SQLPG117 asks every view for security_invoker (15), so it is not also a portability finding.
+            if (name === "security_invoker")
+                continue;
+            const since = rangeOf("storageParameters", `${target}.${name}`)?.since;
+            if (since !== undefined && since > major)
+                note(o.export, `the storage parameter ${name}`, since);
+        }
+    }
+    for (const t of tablesOf(ctx)) {
+        for (const c of t.checks)
+            if (c.notEnforced !== undefined && major < 18)
+                note(t.export, `a NOT ENFORCED / ENFORCED constraint${c.name ? ` ${c.name}` : ""}`, 18);
+        for (const fk of t.foreignKeys)
+            if (fk.notEnforced !== undefined && major < 18)
+                note(t.export, `a NOT ENFORCED / ENFORCED foreign key${fk.name ? ` ${fk.name}` : ""}`, 18);
+        for (const c of t.columns)
+            if (c.generated?.kind === "virtual" && major < 18)
+                note(t.export, `the virtual generated column ${c.name}`, 18);
+        const nulls = [...t.uniques, ...(t.primaryKey ? [t.primaryKey] : [])].some((k) => k.nullsNotDistinct);
+        if (nulls && major < 15)
+            note(t.export, "NULLS NOT DISTINCT", 15);
+    }
+    for (const i of indexesOf(ctx))
+        if (i.nullsNotDistinct && major < 15)
+            note(i.export, "NULLS NOT DISTINCT", 15);
+});

package/dist/lint/post-synth/sqlpg116.js

@@ -0,0 +1,26 @@
+import { checkOf, rangeOf, targetMajor } from "./postgres-helpers.js";
+import { postgresObjects } from "./sql-helpers.js";
+/**
+ * SQLPG116: an extension the target major no longer ships.
+ *
+ * Doc: https://www.postgresql.org/docs/18/contrib.html and the release notes
+ * of the major that dropped it (adminpack and old_snapshot are gone after 16,
+ * https://www.postgresql.org/docs/17/release-17.html). The target is `postgresMajor` in the output. The extension names
+ * and their since/until majors come from the generated catalog, read from
+ * pg_available_extensions of each major's server image.
+ */
+export const sqlpg116 = checkOf({ id: "SQLPG116", description: "An extension the target major no longer ships" }, (ctx, report) => {
+    const major = targetMajor(ctx);
+    for (const o of postgresObjects(ctx)) {
+        if (o.type !== "Postgres::Extension")
+            continue;
+        const until = rangeOf("extensions", o.name)?.until;
+        if (until === undefined || until >= major)
+            continue;
+        report({
+            severity: "error",
+            message: `${o.export} installs the ${o.name} extension, which Postgres ${major} does not ship (last in ${until})`,
+            entity: o.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlpg117.js

@@ -0,0 +1,24 @@
+import { checkOf, isView, storageParams } from "./postgres-helpers.js";
+import { postgresObjects } from "./sql-helpers.js";
+/**
+ * SQLPG117: a view that runs with its owner's privileges.
+ *
+ * Doc: https://www.postgresql.org/docs/18/sql-createview.html ("by default,
+ * access to the underlying base relations referenced in the view is determined
+ * by the permissions of the view owner"; with security_invoker = true it is the
+ * caller's, and the base tables' row-level security applies to the caller).
+ * A view over tables with RLS otherwise hands the owner's view of the rows to
+ * every role that can select from it.
+ */
+export const sqlpg117 = checkOf({ id: "SQLPG117", description: "A view without security_invoker runs with its owner's privileges" }, (ctx, report) => {
+    for (const v of postgresObjects(ctx).filter(isView)) {
+        const flag = storageParams(v.with).get("security_invoker");
+        if (flag === "true" || flag === "on" || flag === "1" || flag === "'true'" || flag === "'on'")
+            continue;
+        report({
+            severity: "warning",
+            message: `${v.export} (${v.sqlName}) does not set security_invoker = true, so it reads its tables as its owner and skips the caller's row-level security`,
+            entity: v.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlpg118.js

@@ -0,0 +1,22 @@
+import { checkOf, tablesOf } from "./postgres-helpers.js";
+/**
+ * SQLPG118: a table that uses INHERITS.
+ *
+ * Doc: https://www.postgresql.org/docs/18/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE-BEST-PRACTICES
+ * and https://www.postgresql.org/docs/18/ddl-inherit.html#DDL-INHERIT-CAVEATS
+ * (indexes, unique constraints and foreign keys are not inherited, so a
+ * constraint on the parent does not cover the children). Declarative
+ * partitioning (PARTITION BY ... / PARTITION OF) replaced inheritance for
+ * splitting a table; INHERITS is kept for its other uses.
+ */
+export const sqlpg118 = checkOf({ id: "SQLPG118", description: "A table uses INHERITS where declarative partitioning replaced it" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        if (t.inherits.length === 0)
+            continue;
+        report({
+            severity: "warning",
+            message: `${t.export} (${t.sqlName}) uses INHERITS; its parent's unique and foreign keys do not cover it, so use PARTITION OF for a split table`,
+            entity: t.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlpg119.js

@@ -0,0 +1,41 @@
+import { checkOf, tablesOf } from "./postgres-helpers.js";
+import { parseType, projectOf, resolveType, typeLabel } from "./postgres-names.js";
+/**
+ * SQLPG119: a column, array element, domain base or sequence `AS` type the
+ * target major does not have.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype.html. The server refuses
+ * `type "numerik" does not exist` at CREATE. A built-in type counts in every
+ * spelling Postgres accepts: the catalog's `pg_type` name and `format_type()`
+ * name (`int4`, `integer`), and the grammar's own spellings (`int`, `decimal`,
+ * `double precision`, `time with time zone`), an overlay beside the catalog.
+ * So does a type the project declares (`type`, `domain`, a table's row type),
+ * by `${}` or by name. A type qualified with a schema the project does not
+ * declare is a plain-text reference and left to the server. An unknown name is
+ * a warning when the project declares an extension, since extension types are
+ * not in the core catalog; the overlay of common extension types answers for
+ * the ones it knows.
+ */
+export const sqlpg119 = checkOf({ id: "SQLPG119", description: "A column, domain or sequence type the target major does not have" }, (ctx, report) => {
+    const p = projectOf(ctx);
+    const check = (entity, sqlName, what, text, serial) => {
+        const t = parseType(text);
+        if (!t)
+            return;
+        const r = resolveType(p, t, { serial });
+        if (r.kind !== "missing")
+            return;
+        const kind = t.array ? "array element type" : "type";
+        report({ severity: r.miss.severity, message: `${entity} (${sqlName}) ${what} ${kind} ${typeLabel(t)}, which Postgres ${p.major} does not have${r.miss.note}`, entity });
+    };
+    for (const t of tablesOf(ctx)) {
+        for (const c of t.columns)
+            check(t.export, t.sqlName, `column ${c.name} has`, c.type, true);
+    }
+    for (const o of p.objects) {
+        if (o.type === "Postgres::Domain")
+            check(o.export, o.sqlName, "is a domain over", o.dataType, false);
+        if (o.type === "Postgres::Sequence")
+            check(o.export, o.sqlName, "is a sequence of", o.dataType, false);
+    }
+});

package/dist/lint/post-synth/sqlpg120.js

@@ -0,0 +1,83 @@
+import { checkOf, tablesOf } from "./postgres-helpers.js";
+import { parametersOf, parseType, projectOf, resolveType, typeLabel } from "./postgres-names.js";
+/**
+ * SQLPG120: a type modifier that does not fit the type.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype-numeric.html,
+ * https://www.postgresql.org/docs/18/datatype-character.html,
+ * https://www.postgresql.org/docs/18/datatype-datetime.html,
+ * https://www.postgresql.org/docs/18/datatype-bit.html. The server refuses a
+ * modifier on a type that takes none (`bigint(8)`), `numeric` precision
+ * outside 1 to 1000 or scale outside -1000 to 1000 (0 to the precision before
+ * 15), `varchar(n)` or `char(n)` outside 1 to 10485760, `timestamp`, `time`
+ * or `interval` precision outside 0 to 6, `bit(n)` below 1, and `float(p)`
+ * outside 1 to 53. The parameters and ranges are the lexicon's type overlay.
+ * Only built-in types are checked: a declared or extension type's modifiers
+ * are its own (`geometry(Point, 4326)`).
+ */
+export const sqlpg120 = checkOf({ id: "SQLPG120", description: "A type modifier that does not fit the type" }, (ctx, report) => {
+    const p = projectOf(ctx);
+    const check = (entity, sqlName, what, text, serial) => {
+        const t = parseType(text);
+        if (!t)
+            return;
+        const problem = modifierProblem(p, t, serial);
+        if (problem)
+            report({ severity: "error", message: `${entity} (${sqlName}) ${what} ${text.trim()}: ${problem}`, entity });
+    };
+    for (const t of tablesOf(ctx))
+        for (const c of t.columns)
+            check(t.export, t.sqlName, `column ${c.name} has type`, c.type, true);
+    for (const o of p.objects) {
+        if (o.type === "Postgres::Domain")
+            check(o.export, o.sqlName, "is a domain over", o.dataType, false);
+        if (o.type === "Postgres::Sequence")
+            check(o.export, o.sqlName, "is a sequence of", o.dataType, false);
+    }
+});
+const int = (s) => (/^[+-]?\d+$/.test(s.trim()) ? Number(s.trim()) : undefined);
+function modifierProblem(p, t, serial) {
+    if (t.schema !== undefined || t.quoted)
+        return undefined;
+    const mods = t.modifiers;
+    if (t.name === "float" && mods) {
+        const n = mods.length === 1 ? int(mods[0]) : undefined;
+        if (mods.length !== 1)
+            return "float takes one precision";
+        if (n !== undefined && (n < 1 || n > 53))
+            return `float precision ${n} is outside 1 to 53`;
+        return undefined;
+    }
+    const r = resolveType(p, t, { serial });
+    if (r.kind !== "builtin")
+        return undefined;
+    const params = parametersOf(r.canonical);
+    if (t.fields !== undefined) {
+        const fields = params.find((a) => a.kind === "keyword")?.values ?? [];
+        if (!fields.includes(t.fields))
+            return `${t.fields} is not an interval field (${fields.join(", ")})`;
+    }
+    if (!mods)
+        return undefined;
+    const numbers = params.filter((a) => a.kind === "number");
+    if (numbers.length === 0)
+        return `${typeLabel(t)} takes no type modifier`;
+    if (mods.length > numbers.length)
+        return `${typeLabel(t)} takes at most ${numbers.length} modifier${numbers.length === 1 ? "" : "s"}`;
+    const values = mods.map(int);
+    for (let i = 0; i < mods.length; i++) {
+        const v = values[i];
+        const spec = numbers[i];
+        if (v === undefined || !spec.range)
+            continue;
+        let [lo, hi] = spec.range;
+        // numeric's scale: 0 to the precision before 15, -1000 to 1000 since.
+        if (r.canonical === "numeric" && spec.name === "scale" && p.major < 15) {
+            lo = 0;
+            hi = values[0] ?? hi;
+        }
+        if (v < lo || v > hi)
+            return `${spec.name} ${v} is outside ${lo} to ${hi}${r.canonical === "numeric" && spec.name === "scale" && p.major < 15 ? ` at Postgres ${p.major}` : ""}`;
+    }
+    return undefined;
+}

package/dist/lint/post-synth/sqlpg121.js

@@ -0,0 +1,33 @@
+import { checkOf, tablesOf } from "./postgres-helpers.js";
+import { parseType, projectOf, resolveType } from "./postgres-names.js";
+const IDENTITY_TYPES = new Set(["smallint", "integer", "bigint"]);
+/**
+ * SQLPG121: an identity column whose type is not `smallint`, `integer` or
+ * `bigint`.
+ *
+ * Doc: https://www.postgresql.org/docs/18/sql-createtable.html ("GENERATED {
+ * ALWAYS | BY DEFAULT } AS IDENTITY ... The column ... must be of type
+ * smallint, integer or bigint"). The server refuses `identity column type must
+ * be smallint, integer, or bigint` at CREATE. A declared type (a domain) is
+ * left to the server.
+ */
+export const sqlpg121 = checkOf({ id: "SQLPG121", description: "An identity column whose type is not smallint, integer or bigint" }, (ctx, report) => {
+    const p = projectOf(ctx);
+    for (const t of tablesOf(ctx)) {
+        for (const c of t.columns) {
+            if (c.generated?.kind !== "identity")
+                continue;
+            const parsed = parseType(c.type);
+            if (!parsed)
+                continue;
+            const r = resolveType(p, parsed, { serial: true });
+            if (r.kind !== "builtin" || (IDENTITY_TYPES.has(r.canonical) && !parsed.array))
+                continue;
+            report({
+                severity: "error",
+                message: `${t.export} (${t.sqlName}) column ${c.name} is an identity column of type ${c.type}; an identity column must be smallint, integer or bigint`,
+                entity: t.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlpg122.js

@@ -0,0 +1,27 @@
+import { checkOf, tablesOf } from "./postgres-helpers.js";
+import { postgresObjects } from "./sql-helpers.js";
+const repeated = (xs) => [...new Set(xs.filter((x, i) => xs.indexOf(x) !== i))];
+/**
+ * SQLPG122: a table that declares a column twice, or an enum that lists a
+ * label twice.
+ *
+ * Doc: https://www.postgresql.org/docs/18/sql-createtable.html and
+ * https://www.postgresql.org/docs/18/sql-createtype.html. The server refuses
+ * `column "id" specified more than once` and `enum labels must be unique`.
+ * Column names are compared as Postgres folds them; labels as written, since
+ * they are case-sensitive strings.
+ */
+export const sqlpg122 = checkOf({ id: "SQLPG122", description: "A table declares a column twice, or an enum lists a label twice" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        for (const name of repeated(t.columns.map((c) => c.name))) {
+            report({ severity: "error", message: `${t.export} (${t.sqlName}) declares the column ${name} more than once`, entity: t.export });
+        }
+    }
+    for (const o of postgresObjects(ctx)) {
+        if (o.type !== "Postgres::Enum")
+            continue;
+        for (const label of repeated(o.labels ?? [])) {
+            report({ severity: "error", message: `${o.export} (${o.sqlName}) lists the enum label '${label}' more than once`, entity: o.export });
+        }
+    }
+});

package/dist/lint/post-synth/sqlpg123.js

@@ -0,0 +1,69 @@
+import { checkOf, indexesOf, tablesOf } from "./postgres-helpers.js";
+import { columnsOf, includeColumns, interpolatedTable, projectOf } from "./postgres-names.js";
+/**
+ * SQLPG123: a bare column name in a key, index or grant column list that the
+ * table does not declare.
+ *
+ * Doc: https://www.postgresql.org/docs/18/sql-createtable.html,
+ * https://www.postgresql.org/docs/18/sql-createindex.html,
+ * https://www.postgresql.org/docs/18/sql-grant.html. The server refuses
+ * `column "idd" named in key does not exist` (or `column "emial" does not
+ * exist`) at CREATE or GRANT. Checked: `PRIMARY KEY`, `UNIQUE` and their
+ * `INCLUDE`, a foreign key's own columns, an index's bare columns and
+ * `INCLUDE` on a `${}` table, and a `GRANT`/`REVOKE` column list on a `${}`
+ * table. An expression (an index expression, a CHECK, a generated column) is
+ * left to the server, as is a table whose columns come from somewhere the
+ * build cannot see (`LIKE`, `OF type`, a plain-text parent).
+ */
+export const sqlpg123 = checkOf({ id: "SQLPG123", description: "A key, index or grant column list names a column the table does not declare" }, (ctx, report) => {
+    const p = projectOf(ctx);
+    const verify = (entity, sqlName, where, tableName, names, cols) => {
+        for (const n of new Set(names)) {
+            if (cols.has(n))
+                continue;
+            report({ severity: "error", message: `${entity} (${sqlName}) ${where} names the column ${n}, which ${tableName} does not declare`, entity });
+        }
+    };
+    for (const t of tablesOf(ctx)) {
+        const cols = columnsOf(p, t);
+        if (!cols)
+            continue;
+        if (t.primaryKey) {
+            verify(t.export, t.sqlName, "PRIMARY KEY", t.sqlName, t.primaryKey.columns, cols);
+            verify(t.export, t.sqlName, "PRIMARY KEY ... INCLUDE", t.sqlName, includeColumns(t.primaryKey.include), cols);
+        }
+        for (const u of t.uniques) {
+            verify(t.export, t.sqlName, "UNIQUE", t.sqlName, u.columns, cols);
+            verify(t.export, t.sqlName, "UNIQUE ... INCLUDE", t.sqlName, includeColumns(u.include), cols);
+        }
+        for (const fk of t.foreignKeys)
+            verify(t.export, t.sqlName, `FOREIGN KEY to ${fk.refTable}`, t.sqlName, fk.columns, cols);
+    }
+    for (const i of indexesOf(ctx)) {
+        const t = interpolatedTable(p, i.table, i.tableName);
+        const cols = t && columnsOf(p, t);
+        if (!cols)
+            continue;
+        verify(i.export, i.sqlName, `index on ${i.tableName}`, i.tableName, i.elements.flatMap((e) => (e.column ? [e.column] : [])), cols);
+        verify(i.export, i.sqlName, `index on ${i.tableName} INCLUDE`, i.tableName, includeColumns(i.include), cols);
+    }
+    for (const g of p.objects) {
+        if (g.type !== "Postgres::Grant" || g.on !== "table")
+            continue;
+        const objects = g.objects ?? [];
+        const names = g.objectNames ?? [];
+        const privileges = g.privileges ?? [];
+        objects.forEach((ref, n) => {
+            const t = interpolatedTable(p, ref, names[n]);
+            const cols = t && columnsOf(p, t);
+            if (!cols)
+                return;
+            for (const priv of privileges) {
+                if (!priv.columns?.length)
+                    continue;
+                const action = g.action === "revoke" ? "REVOKE" : "GRANT";
+                verify(g.export, String(g.name), `${action} ${priv.privilege.toUpperCase()} on ${t.sqlName}`, t.sqlName, priv.columns, cols);
+            }
+        });
+    }
+});

package/dist/lint/post-synth/sqlpg124.js

@@ -0,0 +1,50 @@
+import { checkOf, tablesOf } from "./postgres-helpers.js";
+import { columnsOf, interpolatedTable, projectOf, typeIdentity } from "./postgres-names.js";
+/**
+ * SQLPG124: a foreign key to a `${}` table that names a column the table does
+ * not declare, or pairs columns whose types do not compare.
+ *
+ * Doc: https://www.postgresql.org/docs/18/ddl-constraints.html#DDL-CONSTRAINTS-FK
+ * and https://www.postgresql.org/docs/18/catalog-pg-type.html#CATALOG-TYPCATEGORY-TABLE.
+ * The server refuses `column "idd" referenced in foreign key constraint does
+ * not exist` and `Key columns "customer_id" and "id" are of incompatible
+ * types: text and bigint`. Types compare by their catalog category: `integer`
+ * to `bigint` (both numeric) passes, `text` to `bigint` fails. The
+ * user-defined category (`uuid`, `bytea`, `jsonb`...) compares by type; a
+ * domain by its base type; an enum by itself. A key to a table named in plain
+ * text, or a type outside the project, is left to the server.
+ */
+export const sqlpg124 = checkOf({ id: "SQLPG124", description: "A foreign key names a column the referenced table lacks, or one of another type category" }, (ctx, report) => {
+    const p = projectOf(ctx);
+    for (const t of tablesOf(ctx)) {
+        const own = columnsOf(p, t);
+        for (const fk of t.foreignKeys) {
+            const ref = interpolatedTable(p, fk.references, fk.refTable);
+            const refCols = ref && columnsOf(p, ref);
+            if (!ref || !refCols)
+                continue;
+            const targets = fk.refColumns.length > 0 ? fk.refColumns : (ref.primaryKey?.columns ?? []);
+            const missing = targets.filter((c) => !refCols.has(c));
+            for (const c of missing) {
+                report({ severity: "error", message: `${t.export} (${t.sqlName}) has a foreign key on (${fk.columns.join(", ")}) to ${ref.sqlName} (${c}), which ${ref.sqlName} does not declare`, entity: t.export });
+            }
+            if (missing.length > 0 || !own || targets.length !== fk.columns.length)
+                continue;
+            fk.columns.forEach((c, n) => {
+                const mine = own.get(c);
+                const theirs = refCols.get(targets[n]);
+                if (!mine || !theirs)
+                    return;
+                const a = typeIdentity(p, mine.type);
+                const b = typeIdentity(p, theirs.type);
+                if (a === undefined || b === undefined || a === b)
+                    return;
+                report({
+                    severity: "error",
+                    message: `${t.export} (${t.sqlName}) has a foreign key from ${c} (${mine.type}) to ${ref.sqlName} (${targets[n]}) (${theirs.type}); the types do not compare, so Postgres refuses the key`,
+                    entity: t.export,
+                });
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlpg125.js

@@ -0,0 +1,41 @@
+import { checkOf, indexesOf } from "./postgres-helpers.js";
+import { parseIndexElement, projectOf, resolveMethod, resolveOpClass } from "./postgres-names.js";
+/**
+ * SQLPG125: an index access method or operator class the target major does
+ * not have, or an operator class that is not for the index's method.
+ *
+ * Doc: https://www.postgresql.org/docs/18/sql-createindex.html and
+ * https://www.postgresql.org/docs/18/indexes-opclass.html. The server refuses
+ * `access method "btreee" does not exist` and `operator class "numeric_opz"
+ * does not exist for access method "btree"` at CREATE. Methods and operator
+ * classes come from the target major's catalog (`pg_am`, `pg_opclass`). The
+ * ones an extension adds (`gin_trgm_ops` from pg_trgm, `hnsw` from vector)
+ * pass when the project declares that extension and are an error naming it
+ * when it does not; one neither the catalog nor the extension overlay knows is
+ * a warning when the project declares any extension. An operator class
+ * qualified with a schema the project does not declare is left alone.
+ */
+export const sqlpg125 = checkOf({ id: "SQLPG125", description: "An index access method or operator class the target major does not have, or not for that method" }, (ctx, report) => {
+    const p = projectOf(ctx);
+    for (const i of indexesOf(ctx)) {
+        const method = i.method ?? "btree";
+        const m = resolveMethod(p, method);
+        if (!m.ok) {
+            report({ severity: m.miss.severity, message: `${i.export} (${i.sqlName}) uses the index access method ${method}, which Postgres ${p.major} does not have${m.miss.note}`, entity: i.export });
+            continue;
+        }
+        for (const e of i.elements) {
+            const opclass = parseIndexElement(e.expr)?.opclass;
+            if (!opclass)
+                continue;
+            const r = resolveOpClass(p, method, opclass);
+            if (r.ok)
+                continue;
+            const label = `${opclass.schema ? `${opclass.schema}.` : ""}${opclass.name}`;
+            const message = r.otherMethods
+                ? `${i.export} (${i.sqlName}) uses the operator class ${label}, which is for ${r.otherMethods.join(", ")}, not ${method}`
+                : `${i.export} (${i.sqlName}) uses the operator class ${label}, which Postgres ${p.major} does not have for ${method}${r.miss.note}`;
+            report({ severity: r.miss.severity, message, entity: i.export });
+        }
+    }
+});

package/dist/lint/post-synth/sqlpg126.js

@@ -0,0 +1,38 @@
+import { checkOf } from "./postgres-helpers.js";
+import { callsIn, expressionsOf, projectOf, resolveCall } from "./postgres-names.js";
+/**
+ * SQLPG126: a call to a function the target major does not have, in a column
+ * `DEFAULT`, a generated column, a `CHECK` (a table's or a domain's), or an
+ * index expression.
+ *
+ * Doc: https://www.postgresql.org/docs/18/functions.html. The server refuses
+ * `function noww() does not exist` at CREATE. A name counts when it is in
+ * the target major's `pg_proc`, a function or procedure the project declares,
+ * a type name used as a cast (`int4(x)`), or qualified with a schema the
+ * project does not declare. Only a name directly followed by `(`, outside
+ * string literals, is a call; the grammar's own constructs that read like
+ * calls (`COALESCE`, `NULLIF`, `GREATEST`, `LEAST`, `CAST`, `EXTRACT`, `ROW`,
+ * `ARRAY`, `EXISTS`, `IN`, `ANY`, `ALL`, `SOME`, and the key word forms of
+ * `OVERLAY`, `POSITION`, `SUBSTRING` and `TRIM`) are reserved or column-name
+ * key words, not `pg_proc` names, and are skipped by their key word category.
+ * An error, or a warning when the project declares an extension.
+ */
+export const sqlpg126 = checkOf({ id: "SQLPG126", description: "An expression calls a function the target major does not have" }, (ctx, report) => {
+    const p = projectOf(ctx);
+    for (const o of p.objects) {
+        const seen = new Set();
+        for (const { where, expr } of expressionsOf(o)) {
+            for (const c of callsIn(expr)) {
+                const label = `${c.schema ? `${c.schema}.` : ""}${c.name}`;
+                if (seen.has(`${where}\0${label}`))
+                    continue;
+                seen.add(`${where}\0${label}`);
+                const r = resolveCall(p, c);
+                if (r.ok)
+                    continue;
+                const why = r.since !== undefined ? `, which needs Postgres ${r.since}; Postgres ${p.major} does not have it` : r.until !== undefined ? `, which Postgres removed after ${r.until}` : `, which Postgres ${p.major} does not have`;
+                report({ severity: r.miss.severity, message: `${o.export} (${o.sqlName}) ${where} calls ${label}()${why}${r.miss.note}`, entity: o.export });
+            }
+        }
+    }
+});

package/dist/lint/rules/index.js

@@ -0,0 +1,12 @@
+import { sqlch001 } from "./sqlch001.js";
+import { sqlch002 } from "./sqlch002.js";
+import { sqlch003 } from "./sqlch003.js";
+import { sqlch004 } from "./sqlch004.js";
+import { sqlpg001 } from "./sqlpg001.js";
+import { sqlpg002 } from "./sqlpg002.js";
+import { sqlpg003 } from "./sqlpg003.js";
+import { sqlpg004 } from "./sqlpg004.js";
+import { sqlpg005 } from "./sqlpg005.js";
+export { sqlch001, sqlch002, sqlch003, sqlch004, sqlpg001, sqlpg002, sqlpg003, sqlpg004, sqlpg005 };
+/** The lexicon's source-level lint rules, returned by `lintRules()`. */
+export const rules = [sqlch001, sqlch002, sqlch003, sqlch004, sqlpg001, sqlpg002, sqlpg003, sqlpg004, sqlpg005];

package/dist/lint/rules/postgres-templates.js

@@ -0,0 +1,27 @@
+/**
+ * Finding the Postgres tags in a source file, for the source-level rules. A
+ * tag is Postgres's because of the module it is imported from: the
+ * `/postgres` subpath, or the package root for the tags whose names
+ * ClickHouse does not export (the root's `table` and `view` are
+ * ClickHouse's).
+ */
+import { tokenize } from "../../postgres/tokens.js";
+import { findSqlTemplates } from "../../core/find-templates.js";
+export { templatePosition, tokenPosition } from "../../core/find-templates.js";
+export const POSTGRES_TEMPLATE_SOURCES = [
+    {
+        dialect: "postgres",
+        modules: ["@intentius/chant-lexicon-sql/postgres"],
+        tags: ["schema", "table", "index", "view", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "collation", "cast", "policy", "role", "grant"],
+    },
+    {
+        dialect: "postgres",
+        modules: ["@intentius/chant-lexicon-sql"],
+        tags: ["schema", "index", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "collation", "cast", "policy", "role", "grant"],
+    },
+];
+/** Every Postgres template in the file. */
+export function findPostgresTemplates(source) {
+    return findSqlTemplates(source, POSTGRES_TEMPLATE_SOURCES);
+}
+export const postgresTokensOf = (found) => tokenize(found.parts);