@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.0

package/dist/rules/sqlch119.ts

@@ -0,0 +1,31 @@
+import { DATABASE_ENGINES, TABLE_ENGINES } from "../../generated/clickhouse";
+import { checkOf } from "./clickhouse-helpers";
+import { clickhouseObjects } from "./sql-helpers";
+
+/**
+ * SQLCH119: an engine the pinned catalog describes as deprecated or experimental.
+ *
+ * Docs: https://clickhouse.com/docs/engines/database-engines/ordinary (the
+ * legacy, deprecated default replaced by Atomic) and the engine pages the
+ * snapshot's summaries come from (`This engine is experimental`,
+ * ExperimentalBadge). The words are read from the committed catalog snapshot,
+ * so a pin move changes the verdict.
+ */
+export const sqlch119 = checkOf({ id: "SQLCH119", description: "An object uses a deprecated or experimental engine" }, (ctx, report) => {
+  const tables = TABLE_ENGINES as Record<string, { summary: string } | undefined>;
+  const databases = DATABASE_ENGINES as Record<string, { summary: string } | undefined>;
+  for (const o of clickhouseObjects(ctx)) {
+    const name = o.engine?.name;
+    if (!name) continue;
+    const isDatabase = o.type === "ClickHouse::Database";
+    const summary = (isDatabase ? databases : tables)[name]?.summary ?? "";
+    const deprecated = /\bdeprecated\b/i.test(summary);
+    const experimental = isDatabase ? /ExperimentalBadge/.test(summary) : /\b(is|are) (an )?experimental\b/i.test(summary);
+    if (!deprecated && !experimental) continue;
+    report({
+      severity: "warning",
+      message: `${o.export} (${o.name}) uses the ${deprecated ? "deprecated" : "experimental"} engine ${name}`,
+      entity: o.export,
+    });
+  }
+});

package/dist/rules/sqlch120.ts

@@ -0,0 +1,21 @@
+import { checkOf, isTable } from "./clickhouse-helpers";
+import { clickhouseObjects } from "./sql-helpers";
+
+/**
+ * SQLCH120: a MergeTree engine written with the legacy positional arguments.
+ *
+ * Doc: https://clickhouse.com/docs/engines/table-engines/mergetree-family/mergetree
+ * ("Deprecated Method for Creating a Table": `MergeTree(date-column
+ * [, sampling_expression], (primary, key), index_granularity)`). Current
+ * syntax is a bare `MergeTree` with ORDER BY, PARTITION BY and SETTINGS.
+ */
+export const sqlch120 = checkOf({ id: "SQLCH120", description: "A MergeTree engine uses the deprecated positional arguments" }, (ctx, report) => {
+  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+    if (t.engine?.name !== "MergeTree" || (t.engine.args ?? []).length === 0) continue;
+    report({
+      severity: "warning",
+      message: `${t.export} (${t.name}) is MergeTree(${t.engine.args!.join(", ")}), the deprecated positional form; use ORDER BY, PARTITION BY and SETTINGS`,
+      entity: t.export,
+    });
+  }
+});

package/dist/rules/sqlpg001.ts

@@ -0,0 +1,88 @@
+import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
+import { parseStatements, SqlSyntaxError } from "../../postgres/parser";
+import { STATEMENT_NAMES, type PostgresTag } from "../../postgres/entities";
+import { findPostgresTemplates, postgresTokensOf, templatePosition, tokenPosition } from "./postgres-templates";
+
+/** The statement each tag holds. */
+const STATEMENT: Record<PostgresTag, string> = {
+  schema: "schema",
+  table: "table",
+  index: "index",
+  view: "view",
+  sequence: "sequence",
+  type: "enum",
+  domain: "domain",
+  extension: "extension",
+};
+
+const TAG_OF: Record<string, PostgresTag> = Object.fromEntries(Object.entries(STATEMENT).map(([tag, statement]) => [statement, tag as PostgresTag]));
+
+/**
+ * SQLPG001: the DDL in a Postgres template does not parse, or does not hold
+ * what its tag declares.
+ *
+ * The same parse runs when the build calls the tag, and fails the build there.
+ * This rule reports it in the editor and in `chant lint`, at the token, as a
+ * line and column of the `.ts` file, before anything is built. It also reports
+ * what the tag refuses after parsing: another statement than the tag's, a
+ * second CREATE in one template, and an index with no name (its name is its
+ * identity on the server). Interpolations are references here, since lint
+ * cannot know their values, so an error inside text a string interpolation
+ * supplies is left to the build.
+ */
+export const sqlpg001: LintRule = {
+  id: "SQLPG001",
+  severity: "error",
+  category: "correctness",
+  description: "Postgres DDL in a tagged template does not parse, or holds another statement than its tag",
+
+  check(context: LintContext): LintDiagnostic[] {
+    const source = context.sourceFile;
+    const out: LintDiagnostic[] = [];
+    const report = (message: string, at: { line: number; column: number }) =>
+      out.push({ ruleId: "SQLPG001", severity: "error", message, file: context.filePath, ...at });
+    for (const found of findPostgresTemplates(source)) {
+      const tokens = (() => {
+        try {
+          return postgresTokensOf(found);
+        } catch (err) {
+          if (!(err instanceof SqlSyntaxError)) throw err;
+          report(`Postgres DDL does not parse: ${err.message}`, templatePosition(source, found, err.part, err.offset));
+          return undefined;
+        }
+      })();
+      if (!tokens) continue;
+      try {
+        const [node, ...rest] = parseStatements(tokens);
+        if (node!.statement !== STATEMENT[found.tag]) {
+          const use = TAG_OF[node!.statement];
+          report(
+            use
+              ? `${found.tag}\`...\` holds a ${STATEMENT_NAMES[node!.statement]}; use the ${use} tag`
+              : `${found.tag}\`...\` starts with a COMMENT ON; it goes after the CREATE it comments on`,
+            templatePosition(source, found, 0, 0),
+          );
+          continue;
+        }
+        const stray = rest.find((n) => n.statement !== "comment");
+        if (stray) {
+          report(
+            `${found.tag}\`...\` holds a second statement (${STATEMENT_NAMES[stray.statement]}); a template declares one object, followed only by COMMENT ON statements for it`,
+            templatePosition(source, found, 0, 0),
+          );
+        }
+        if (node!.statement === "index" && !node!.name) {
+          const on = tokens.find((t) => t.kind === "ident" && t.text.toUpperCase() === "ON");
+          report(
+            "an index needs a name: the name is its identity on the server, and an unnamed index gets a generated one",
+            on ? tokenPosition(source, found, on) : templatePosition(source, found, 0, 0),
+          );
+        }
+      } catch (err) {
+        if (!(err instanceof SqlSyntaxError)) throw err;
+        report(`Postgres DDL does not parse: ${err.message}`, err.token ? tokenPosition(source, found, err.token) : templatePosition(source, found, err.part, err.offset));
+      }
+    }
+    return out;
+  },
+};

package/dist/rules/sqlpg002.ts

@@ -0,0 +1,68 @@
+import * as ts from "typescript";
+import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
+import { findPostgresTemplates as findTemplates } from "./postgres-templates";
+
+/** The entity's own members: an interpolation of one of them is never a column. */
+const OWN_MEMBERS = new Set(["kind", "lexicon", "entityType", "props", "sqlName", "dependsOn"]);
+
+/**
+ * Identifiers that hold a Postgres entity, as far as one file can tell:
+ * bound to a sql tag here, or imported from another file of the project.
+ */
+function entityBindings(source: ts.SourceFile, tagged: Set<ts.Node>): Set<string> {
+  const out = new Set<string>();
+  for (const stmt of source.statements) {
+    if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text.startsWith(".")) {
+      const named = stmt.importClause?.namedBindings;
+      if (named && ts.isNamedImports(named)) for (const el of named.elements) out.add(el.name.text);
+    }
+    if (ts.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) {
+        if (ts.isIdentifier(d.name) && d.initializer && tagged.has(d.initializer)) out.add(d.name.text);
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * SQLPG002: a column written as `${events.kind}` instead of `${events.columns.kind}`.
+ *
+ * Columns are reached through `.columns`. `kind`, `lexicon`, `entityType`,
+ * `props`, `sqlName` and `dependsOn` are the entity's own fields, so
+ * `${events.kind}` is the string `"resource"`, which the tag splices in as SQL
+ * text: the statement builds and means something else. This rule flags it for
+ * an entity the file declares or imports from another project file.
+ */
+export const sqlpg002: LintRule = {
+  id: "SQLPG002",
+  severity: "error",
+  category: "correctness",
+  description: "A column interpolated without .columns reads the entity's own field instead",
+
+  check(context: LintContext): LintDiagnostic[] {
+    const source = context.sourceFile;
+    const found = findTemplates(source);
+    if (found.length === 0) return [];
+    const entities = entityBindings(source, new Set(found.map((f) => f.node)));
+    const out: LintDiagnostic[] = [];
+    for (const f of found) {
+      for (const expr of f.expressions) {
+        if (!ts.isPropertyAccessExpression(expr) || !ts.isIdentifier(expr.expression)) continue;
+        const owner = expr.expression.text;
+        const member = expr.name.text;
+        if (!entities.has(owner) || !OWN_MEMBERS.has(member)) continue;
+        const { line, character } = source.getLineAndCharacterOfPosition(expr.getStart(source));
+        out.push({
+          ruleId: "SQLPG002",
+          severity: "error",
+          message: `\${${owner}.${member}} is the entity's own "${member}" field, not a column; write \${${owner}.columns.${member}}`,
+          file: context.filePath,
+          line: line + 1,
+          column: character + 1,
+        });
+      }
+    }
+    return out;
+  },
+};

package/dist/rules/sqlpg003.ts

@@ -0,0 +1,59 @@
+import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
+import { isTrivia, SqlSyntaxError } from "../../postgres/tokens";
+import { findPostgresTemplates, postgresTokensOf, tokenPosition } from "./postgres-templates";
+
+const REGCLASS_FUNCTIONS = ["NEXTVAL", "CURRVAL", "SETVAL"];
+
+/**
+ * SQLPG003: an object named in a string where Postgres reads a `regclass`:
+ * `nextval('app.ticket_seq')`, `currval(...)`, `setval(...)`, or
+ * `'app.ticket_seq'::regclass`.
+ *
+ * A name inside a string is text to the build, so it records no reference:
+ * the table does not depend on the sequence, the creation order can put the
+ * table first, and the create fails. Interpolating the object instead,
+ * `nextval(${ticketSeq})`, renders the same `regclass` literal the catalog
+ * prints (`nextval('app.ticket_seq'::regclass)`) and keeps the edge. A
+ * sequence another tool owns is the exception, which is why this is a
+ * warning.
+ */
+export const sqlpg003: LintRule = {
+  id: "SQLPG003",
+  severity: "warning",
+  category: "correctness",
+  description: "A sequence or relation named in a regclass string makes no reference; interpolate the object",
+
+  check(context: LintContext): LintDiagnostic[] {
+    const source = context.sourceFile;
+    const out: LintDiagnostic[] = [];
+    for (const found of findPostgresTemplates(source)) {
+      let tokens;
+      try {
+        tokens = postgresTokensOf(found);
+      } catch (err) {
+        if (err instanceof SqlSyntaxError) continue;
+        throw err;
+      }
+      const sig = tokens.filter((t) => !isTrivia(t));
+      sig.forEach((t, k) => {
+        if (t.kind !== "string" || !t.text.startsWith("'")) return;
+        const prev = sig[k - 1];
+        const fn = sig[k - 2];
+        const inCall =
+          prev?.kind === "punct" && prev.text === "(" && fn?.kind === "ident" && REGCLASS_FUNCTIONS.includes(fn.text.toUpperCase());
+        const cast = sig[k + 1]?.kind === "op" && sig[k + 1]!.text === "::" && sig[k + 2]?.kind === "ident" && sig[k + 2]!.text.toLowerCase() === "regclass";
+        if (!inCall && !cast) return;
+        const named = t.text.slice(1, -1).replace(/''/g, "'");
+        const how = inCall ? `${fn!.text}(\${...})` : "${...}::regclass";
+        out.push({
+          ruleId: "SQLPG003",
+          severity: "warning",
+          message: `'${named}' names an object in a string, which records no reference, so the build can create this object before it; interpolate the declared object instead: ${how}`,
+          file: context.filePath,
+          ...tokenPosition(source, found, t),
+        });
+      });
+    }
+    return out;
+  },
+};

package/dist/rules/sqlpg004.ts

@@ -0,0 +1,73 @@
+import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
+import { isTrivia, SqlSyntaxError, type Token } from "../../postgres/tokens";
+import { isPostgresProvider, providerAllowsExtension, providerData } from "../../postgres/providers";
+import type { PostgresProvider } from "../../postgres/providers";
+import { findPostgresTemplates, postgresTokensOf, tokenPosition } from "./postgres-templates";
+
+/**
+ * The provider a lint run is for: `sql.provider`, else the one provider every
+ * profile that names one agrees on. No answer (self-hosted, or profiles that
+ * disagree) leaves the rule silent. The lint engine passes the whole project
+ * config as `projectConfig`.
+ */
+export function providerFromConfig(config: unknown): PostgresProvider | undefined {
+  const sql = (config as { sql?: { provider?: unknown; profiles?: Record<string, { provider?: unknown }> } } | undefined)?.sql;
+  if (!sql) return undefined;
+  if (isPostgresProvider(sql.provider)) return sql.provider;
+  const named = new Set(Object.values(sql.profiles ?? {}).map((p) => p.provider).filter(isPostgresProvider));
+  return named.size === 1 ? [...named][0] : undefined;
+}
+
+const unquote = (t: Token): string => (t.kind === "qident" ? t.text.slice(1, -1).replace(/""/g, '"') : t.text.toLowerCase());
+
+/**
+ * SQLPG004: a declared extension the configured provider does not allow.
+ *
+ * `extension\`CREATE EXTENSION pg_stat_monitor\`` builds, and fails when
+ * applied to a provider whose list lacks it. The lists are the providers'
+ * documentation snapshots (see postgres/providers/types.ts), so a provider
+ * that added an extension since reports it here until the list is refreshed;
+ * disable the rule for that line. When a provider's list is partial, a name
+ * outside it is not reported.
+ */
+export const sqlpg004: LintRule = {
+  id: "SQLPG004",
+  severity: "error",
+  category: "correctness",
+  description: "A declared extension the configured Postgres provider does not allow",
+
+  check(context: LintContext): LintDiagnostic[] {
+    const provider = providerFromConfig(context.projectConfig);
+    if (!provider) return [];
+    const label = providerData(provider).label;
+    const source = context.sourceFile;
+    const out: LintDiagnostic[] = [];
+    for (const found of findPostgresTemplates(source)) {
+      if (found.tag !== "extension") continue;
+      let tokens: Token[];
+      try {
+        tokens = postgresTokensOf(found);
+      } catch (err) {
+        if (err instanceof SqlSyntaxError) continue;
+        throw err;
+      }
+      const sig = tokens.filter((t) => !isTrivia(t));
+      const word = (k: number) => (sig[k]?.kind === "ident" ? sig[k]!.text.toUpperCase() : "");
+      if (word(0) !== "CREATE" || word(1) !== "EXTENSION") continue;
+      let k = 2;
+      if (word(k) === "IF" && word(k + 1) === "NOT" && word(k + 2) === "EXISTS") k += 3;
+      const nameToken = sig[k];
+      if (!nameToken || (nameToken.kind !== "ident" && nameToken.kind !== "qident")) continue;
+      const name = unquote(nameToken);
+      if (providerAllowsExtension(provider, name) !== false) continue;
+      out.push({
+        ruleId: "SQLPG004",
+        severity: "error",
+        message: `${label} does not allow the extension "${name}"; CREATE EXTENSION would fail there. Use an extension it lists, or change sql.provider`,
+        file: context.filePath,
+        ...tokenPosition(source, found, nameToken),
+      });
+    }
+    return out;
+  },
+};

package/dist/rules/sqlpg101.ts

@@ -0,0 +1,24 @@
+import { checkOf, ownsColumns, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG101: a table with no primary key.
+ *
+ * Doc: https://www.postgresql.org/docs/18/ddl-constraints.html#DDL-CONSTRAINTS-PRIMARY-KEYS
+ * ("a primary key indicates that a column or group of columns can be used as a
+ * unique identifier for rows"). Without one, logical replication needs a
+ * REPLICA IDENTITY and rows cannot be addressed by identity. A partition, a
+ * typed table and a LIKE copy are skipped, and a UNIQUE constraint over NOT
+ * NULL columns counts as an identity.
+ */
+export const sqlpg101 = checkOf({ id: "SQLPG101", description: "A table declares no primary key" }, (ctx, report) => {
+  for (const t of tablesOf(ctx)) {
+    if (!ownsColumns(t) || t.primaryKey || t.like.length > 0) continue;
+    const notNull = new Set(t.columns.filter((c) => c.notNull).map((c) => c.name));
+    if (t.uniques.some((u) => u.columns.length > 0 && u.columns.every((c) => notNull.has(c)))) continue;
+    report({
+      severity: "warning",
+      message: `${t.export} (${t.sqlName}) has no primary key; add one, or a UNIQUE constraint over NOT NULL columns`,
+      entity: t.export,
+    });
+  }
+});

package/dist/rules/sqlpg102.ts

@@ -0,0 +1,30 @@
+import { checkOf, indexesOf, leadingColumns, ownsColumns, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG102: a foreign key whose referencing columns no index leads with.
+ *
+ * Doc: https://www.postgresql.org/docs/18/ddl-constraints.html#DDL-CONSTRAINTS-FK
+ * ("it is often a good idea to index the referencing columns too ... a delete
+ * of a referenced row requires a scan of the referencing table"). The primary
+ * key, a UNIQUE constraint or an index covers the key when its leading columns
+ * are the foreign key's columns, in any order.
+ */
+export const sqlpg102 = checkOf({ id: "SQLPG102", description: "A foreign key's referencing columns have no index" }, (ctx, report) => {
+  const indexes = indexesOf(ctx);
+  const sameSet = (a: string[], b: string[]) => a.length === b.length && a.every((c) => b.includes(c));
+  for (const t of tablesOf(ctx)) {
+    if (!ownsColumns(t)) continue;
+    const covers: string[][] = [];
+    if (t.primaryKey) covers.push(t.primaryKey.columns);
+    for (const u of t.uniques) covers.push(u.columns);
+    for (const i of indexes) if (i.tableName === t.sqlName && (i.method ?? "btree") === "btree") covers.push(leadingColumns(i));
+    for (const fk of t.foreignKeys) {
+      if (covers.some((c) => c.length >= fk.columns.length && sameSet(c.slice(0, fk.columns.length), fk.columns))) continue;
+      report({
+        severity: "warning",
+        message: `${t.export} (${t.sqlName}) has a foreign key on (${fk.columns.join(", ")}) to ${fk.refTable} with no index leading with those columns; deletes and updates of the referenced row scan the table`,
+        entity: t.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg103.ts

@@ -0,0 +1,23 @@
+import { baseType, checkOf, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG103: a serial column where an identity column is preferred.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype-numeric.html#DATATYPE-SERIAL
+ * (serial is a notational convenience that creates a sequence the column does
+ * not own as a constraint); https://www.postgresql.org/docs/18/sql-createtable.html
+ * documents GENERATED ... AS IDENTITY, the standard form. Prior art: squawk
+ * prefer-identity.
+ */
+export const sqlpg103 = checkOf({ id: "SQLPG103", description: "A serial column where an identity column is preferred" }, (ctx, report) => {
+  for (const t of tablesOf(ctx)) {
+    for (const c of t.columns) {
+      if (!/^(small|big)?serial[248]?$/.test(baseType(c.type))) continue;
+      report({
+        severity: "warning",
+        message: `${t.export}.${c.name} is ${c.type}; declare it as an identity column (GENERATED ALWAYS AS IDENTITY)`,
+        entity: t.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg104.ts

@@ -0,0 +1,23 @@
+import { baseType, checkOf, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG104: a timestamp column without time zone.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype-datetime.html (timestamp
+ * without time zone ignores any zone in the input, so the value means
+ * different instants to clients in different zones); the Postgres wiki's
+ * "Don't Do This" says the same. Prior art: squawk prefer-timestamptz.
+ */
+export const sqlpg104 = checkOf({ id: "SQLPG104", description: "A timestamp column without time zone" }, (ctx, report) => {
+  for (const t of tablesOf(ctx)) {
+    for (const c of t.columns) {
+      const type = baseType(c.type);
+      if (type !== "timestamp" && type !== "timestamp without time zone") continue;
+      report({
+        severity: "warning",
+        message: `${t.export}.${c.name} is ${c.type}; use timestamptz, which stores an instant`,
+        entity: t.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg105.ts

@@ -0,0 +1,22 @@
+import { baseType, checkOf, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG105: a json column where jsonb fits.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype-json.html ("the jsonb data
+ * type is faster to process ... and supports indexing"; json has no equality
+ * operator, so SELECT DISTINCT, GROUP BY and UNION fail on it). Prior art:
+ * strong_migrations "Adding a json column".
+ */
+export const sqlpg105 = checkOf({ id: "SQLPG105", description: "A json column where jsonb fits" }, (ctx, report) => {
+  for (const t of tablesOf(ctx)) {
+    for (const c of t.columns) {
+      if (baseType(c.type) !== "json") continue;
+      report({
+        severity: "warning",
+        message: `${t.export}.${c.name} is json; use jsonb unless the exact text, key order or duplicate keys must be kept`,
+        entity: t.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg106.ts

@@ -0,0 +1,22 @@
+import { baseType, checkOf, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG106: a char(n) column.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype-character.html ("there is
+ * no performance advantage to character(n) ... it takes more storage because
+ * of the blank padding"). Prior art: squawk ban-char-field.
+ */
+export const sqlpg106 = checkOf({ id: "SQLPG106", description: "A char(n) column" }, (ctx, report) => {
+  for (const t of tablesOf(ctx)) {
+    for (const c of t.columns) {
+      const type = baseType(c.type);
+      if (type !== "char" && type !== "character" && type !== "bpchar") continue;
+      report({
+        severity: "warning",
+        message: `${t.export}.${c.name} is ${c.type}, which pads with blanks; use text, or varchar(n) for a length rule`,
+        entity: t.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg107.ts

@@ -0,0 +1,22 @@
+import { baseType, checkOf, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG107: a money column.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype-money.html ("the output of
+ * this type depends on lc_monetary ... restoring a dump into a database with
+ * a different lc_monetary setting may not work"; it holds a fixed number of
+ * decimals and no currency). Use numeric(p, s).
+ */
+export const sqlpg107 = checkOf({ id: "SQLPG107", description: "A money column" }, (ctx, report) => {
+  for (const t of tablesOf(ctx)) {
+    for (const c of t.columns) {
+      if (baseType(c.type) !== "money") continue;
+      report({
+        severity: "warning",
+        message: `${t.export}.${c.name} is money, whose rounding and output depend on lc_monetary; use numeric(p, s) and a currency column`,
+        entity: t.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg108.ts

@@ -0,0 +1,27 @@
+import { baseType, checkOf, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG108: a varchar(n) column whose limit no CHECK or domain explains.
+ *
+ * Doc: https://www.postgresql.org/docs/18/datatype-character.html ("there is
+ * no performance difference among these three types"; a length limit only
+ * buys the check, and raising it later takes a table rewrite on old majors).
+ * Reported only for a limit that is a round number such as 255, the habit of
+ * other databases. Prior art: squawk prefer-text-field.
+ */
+export const sqlpg108 = checkOf({ id: "SQLPG108", description: "A varchar(n) column with a habitual length limit" }, (ctx, report) => {
+  for (const t of tablesOf(ctx)) {
+    for (const c of t.columns) {
+      const type = (c.type ?? "").toLowerCase();
+      const m = /^(?:varchar|character varying)\s*\(\s*(\d+)\s*\)$/.exec(type.trim());
+      if (!m || baseType(type) !== "varchar" && baseType(type) !== "character varying") continue;
+      const n = Number(m[1]);
+      if (![50, 100, 128, 200, 250, 255, 256, 500, 512, 1000, 1024].includes(n)) continue;
+      report({
+        severity: "warning",
+        message: `${t.export}.${c.name} is varchar(${n}); text performs the same, and a CHECK states a real length rule`,
+        entity: t.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg109.ts

@@ -0,0 +1,37 @@
+import { checkOf, indexesOf, tablesOf, type PgIndex } from "./postgres-helpers";
+
+const plain = (i: PgIndex) => (i.method ?? "btree") === "btree" && i.elements.every((e) => e.column);
+const keyOf = (i: PgIndex) => `${i.elements.map((e) => e.column).join(",")}|${i.where ?? ""}|${i.include ?? ""}`;
+
+/**
+ * SQLPG109: an index that duplicates a constraint's index, or another index.
+ *
+ * Doc: https://www.postgresql.org/docs/18/indexes-unique.html ("PostgreSQL
+ * automatically creates a unique index when a unique constraint or a primary
+ * key is defined for a table"), so a second index on the same columns costs
+ * every write and serves no query. Two indexes with the same method, columns,
+ * INCLUDE and predicate are the same index.
+ */
+export const sqlpg109 = checkOf({ id: "SQLPG109", description: "An index duplicates a constraint or another index" }, (ctx, report) => {
+  const indexes = indexesOf(ctx).filter(plain);
+  for (const t of tablesOf(ctx)) {
+    const constraints: Array<{ label: string; cols: string }> = [];
+    if (t.primaryKey) constraints.push({ label: "its primary key", cols: t.primaryKey.columns.join(",") });
+    for (const u of t.uniques) constraints.push({ label: `its unique constraint${u.name ? ` ${u.name}` : ""}`, cols: u.columns.join(",") });
+    const mine = indexes.filter((i) => i.tableName === t.sqlName);
+    const seen = new Map<string, PgIndex>();
+    for (const i of mine) {
+      const key = keyOf(i);
+      const cols = i.elements.map((e) => e.column).join(",");
+      const dup = constraints.find((c) => c.cols === cols && !i.where && !i.include);
+      if (dup) {
+        report({ severity: "warning", message: `${i.export} (${i.sqlName}) indexes (${cols}) on ${t.sqlName}, which ${dup.label} already indexes`, entity: i.export });
+        continue;
+      }
+      const first = seen.get(key);
+      if (first) {
+        report({ severity: "warning", message: `${i.export} (${i.sqlName}) duplicates ${first.export} (${first.sqlName}): same columns on ${t.sqlName}`, entity: i.export });
+      } else seen.set(key, i);
+    }
+  }
+});

package/dist/rules/sqlpg110.ts

@@ -0,0 +1,33 @@
+import { checkOf, indexesOf, leadingColumns, tablesOf } from "./postgres-helpers";
+
+/**
+ * SQLPG110: a btree index whose columns are a leading prefix of another index.
+ *
+ * Doc: https://www.postgresql.org/docs/18/indexes-multicolumn.html ("a
+ * multicolumn B-tree index can be used with query conditions that involve any
+ * subset of the index's columns, but the index is most efficient when there
+ * are constraints on the leading (leftmost) columns"). A plain index on (a)
+ * is served by one on (a, b) or by the primary key (a, b). A unique index
+ * enforces a rule and is kept.
+ */
+export const sqlpg110 = checkOf({ id: "SQLPG110", description: "A btree index is a prefix of another index" }, (ctx, report) => {
+  const indexes = indexesOf(ctx).filter((i) => (i.method ?? "btree") === "btree");
+  for (const t of tablesOf(ctx)) {
+    const wider: Array<{ label: string; cols: string[] }> = [];
+    if (t.primaryKey) wider.push({ label: "the primary key", cols: t.primaryKey.columns });
+    for (const u of t.uniques) wider.push({ label: "a unique constraint", cols: u.columns });
+    const mine = indexes.filter((i) => i.tableName === t.sqlName);
+    for (const i of mine) if (!i.where) wider.push({ label: i.sqlName, cols: leadingColumns(i) });
+    for (const i of mine) {
+      if (i.unique || i.where || i.include || !i.elements.every((e) => e.column)) continue;
+      const cols = i.elements.map((e) => e.column!);
+      const cover = wider.find((w) => w.label !== i.sqlName && w.cols.length > cols.length && cols.every((c, n) => w.cols[n] === c));
+      if (!cover) continue;
+      report({
+        severity: "warning",
+        message: `${i.export} (${i.sqlName}) on (${cols.join(", ")}) is a prefix of ${cover.label} (${cover.cols.join(", ")}); drop it`,
+        entity: i.export,
+      });
+    }
+  }
+});

package/dist/rules/sqlpg111.ts

@@ -0,0 +1,23 @@
+import { checkOf, indexesOf, isMaterializedView } from "./postgres-helpers";
+import { postgresObjects } from "./sql-helpers";
+
+/**
+ * SQLPG111: a materialized view with no unique index.
+ *
+ * Doc: https://www.postgresql.org/docs/18/sql-refreshmaterializedview.html
+ * ("CONCURRENTLY ... is only allowed if there is at least one UNIQUE index on
+ * the materialized view which uses only column names and includes all rows").
+ * Without one, every refresh takes an ACCESS EXCLUSIVE lock and blocks readers.
+ */
+export const sqlpg111 = checkOf({ id: "SQLPG111", description: "A materialized view has no unique index, so it cannot refresh concurrently" }, (ctx, report) => {
+  const indexes = indexesOf(ctx);
+  for (const v of postgresObjects(ctx).filter(isMaterializedView)) {
+    const ok = indexes.some((i) => i.tableName === v.sqlName && i.unique && !i.where && i.elements.every((e) => e.column));
+    if (ok) continue;
+    report({
+      severity: "warning",
+      message: `${v.export} (${v.sqlName}) has no unique index over plain columns; REFRESH MATERIALIZED VIEW CONCURRENTLY is refused and a plain refresh blocks readers`,
+      entity: v.export,
+    });
+  }
+});