@coradb/coradb-sqlsyntaxchecker-wasm 0.3.3

package/schema-check.js

@@ -0,0 +1,715 @@
+// schema-check.js — the name checks.
+//
+// The names in a statement the grammar accepted, looked up in a schema: the
+// tables, views, node and edge classes it uses, their columns, the stored
+// functions and procedures it calls (and how many arguments it passes them),
+// serials, and the values an INSERT gives. The grammar says where each of
+// those is (see EVENTS in build/generate.mjs); this decides
+// what each name means and whether the schema has it.
+//
+// Only what is certain is reported. A name that could mean something this
+// does not know about — a derived table's columns, a system catalog class, an
+// object the same script creates, a part of the schema that was not given — is
+// let through. A false alarm is worse than a missed one.
+/** The kinds of event the grammar reports; the numbers are EVENTS in generate.mjs. */
+const EV = {
+  STMT: 1,
+  QUERY: 2,
+  SELECT: 3,
+  INSERT: 4,
+  UPDATE: 5,
+  DELETE: 6,
+  MERGE: 7,
+  CALL: 8,
+  TABLE: 10,
+  TSPEC: 11,
+  TALIAS: 12,
+  DALIAS: 13,
+  COLUMN: 20,
+  STAR_QUALIFIER: 21,
+  SELECT_ALIAS: 22,
+  CTE: 23,
+  FUNC_NAME: 30,
+  FUNC_ARGS: 31,
+  FUNC_TARGET: 32,
+  NODE_VAR: 40,
+  NODE_LABEL: 41,
+  EDGE_VAR: 42,
+  EDGE_LABELS: 43,
+  INS_TARGET: 50,
+  INS_COLS: 51,
+  INS_VERTEX: 52,
+  INS_EDGE: 53,
+  INS_SETCOL: 54,
+  INS_ROW: 55,
+  INS_ROW_EMPTY: 56,
+};
+const SCOPE_KINDS = new Set([EV.QUERY, EV.SELECT, EV.INSERT, EV.UPDATE, EV.DELETE, EV.MERGE]);
+// --- names -------------------------------------------------------------------
+/** `a.b.c`, with "…", […] and `…` quoting, lower-cased; null when it is not just a name. */
+function nameParts(text) {
+  const parts = [];
+  let i = 0;
+  const n = text.length;
+  const skip = () => {
+    while (i < n && /\s/.test(text[i]))
+      i += 1;
+  };
+  skip();
+  while (i < n) {
+    const ch = text[i];
+    let part;
+    if (ch === '"' || ch === '`' || ch === '[') {
+      const close = ch === '[' ? ']' : ch;
+      const j = text.indexOf(close, i + 1);
+      if (j < 0)
+        return null;
+      part = text.slice(i + 1, j);
+      i = j + 1;
+    }
+    else {
+      const m = /^[A-Za-z_#\u0080-￿][\w#$\u0080-￿]*/.exec(text.slice(i));
+      if (!m)
+        return null;
+      part = m[0];
+      i += m[0].length;
+    }
+    parts.push(part.toLowerCase());
+    skip();
+    if (i >= n)
+      break;
+    if (text[i] !== '.')
+      return null;
+    i += 1;
+    skip();
+  }
+  return parts.length ? parts : null;
+}
+/** The name an alias clause gives: ` t`, `AS t`, `t (a, b)` (renames: columns unknown), `p =`. */
+function aliasOf(text) {
+  let t = text.trim().replace(/=\s*$/, '').trim();
+  t = t.replace(/^AS\s+/i, '');
+  const paren = t.indexOf('(');
+  const renames = paren >= 0;
+  if (renames)
+    t = t.slice(0, paren);
+  const parts = nameParts(t);
+  return parts && parts.length === 1 ? { name: parts[0], renames } : null;
+}
+/**
+ * How many top-level, comma-separated items `text` holds (strings, comments
+ * and brackets skipped). With `backslashEscapes` (no_backslash_escapes off), a
+ * backslash in a string escapes what follows it, as the engine reads it.
+ */
+function countItems(text, backslashEscapes = false) {
+  let depth = 0;
+  let commas = 0;
+  let any = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (ch === "'" || ch === '"' || ch === '`') {
+      let j = i + 1;
+      while (j < text.length) {
+        if (backslashEscapes && ch !== '`' && text[j] === '\\')
+          j += 2;
+        else if (text[j] === ch) {
+          if (text[j + 1] === ch)
+            j += 2;
+          else
+            break;
+        }
+        else
+          j += 1;
+      }
+      i = j;
+      any = true;
+      continue;
+    }
+    if ((ch === '-' && next === '-') || (ch === '/' && next === '/')) {
+      const nl = text.indexOf('\n', i);
+      i = nl < 0 ? text.length : nl;
+      continue;
+    }
+    if (ch === '/' && next === '*') {
+      const close = text.indexOf('*/', i + 2);
+      i = close < 0 ? text.length : close + 1;
+      continue;
+    }
+    if (ch === '(' || ch === '[' || ch === '{')
+      depth += 1;
+    else if (ch === ')' || ch === ']' || ch === '}')
+      depth -= 1;
+    else if (ch === ',' && depth === 0)
+      commas += 1;
+    if (!/\s/.test(ch))
+      any = true;
+  }
+  return any ? commas + 1 : 0;
+}
+/** Each identifier in a bracketed list, `(a, [b], "c")`, with where it is. */
+function listedNames(text, start) {
+  const out = [];
+  const open = text.indexOf('(');
+  const close = text.lastIndexOf(')');
+  if (open < 0 || close < open)
+    return out;
+  let pos = open + 1;
+  for (const piece of text.slice(open + 1, close).split(',')) {
+    const lead = piece.length - piece.trimStart().length;
+    const parts = nameParts(piece);
+    if (parts && parts.length >= 1) {
+      out.push({ name: parts[parts.length - 1], start: start + pos + lead, end: start + pos + lead + piece.trim().length });
+    }
+    pos += piece.length + 1;
+  }
+  return out;
+}
+/** "1", "1 or 2", "2 to 4", "3 or more", from a bit per count. */
+function countWords(mask) {
+  const counts = [];
+  for (let c = 0; c <= 29; c += 1)
+    if (mask & (1 << c))
+      counts.push(c);
+  const more = (mask & (1 << 30)) !== 0;
+  if (more && counts.length > 0 && counts.every((c, i) => i === 0 || c === counts[i - 1] + 1) && counts[counts.length - 1] === 29) {
+    return `${counts[0]} or more`;
+  }
+  if (counts.length === 0)
+    return more ? '30 or more' : 'no';
+  if (counts.length === 1)
+    return String(counts[0]);
+  const contiguous = counts.every((c, i) => i === 0 || c === counts[i - 1] + 1);
+  if (contiguous && counts.length > 2)
+    return `${counts[0]} to ${counts[counts.length - 1]}`;
+  return `${counts.slice(0, -1).join(', ')} or ${counts[counts.length - 1]}`;
+}
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+/**
+ * Names a script creates, renames or changes: CREATE TABLE/VIEW/… x, ALTER …
+ * x, RENAME a TO b, CREATE PROCEDURE/FUNCTION/SERIAL/SYNONYM x. Statements
+ * after (or before) them may use those names, which the schema does not know
+ * yet, so they are let through.
+ */
+export function createdNames(statements) {
+  const out = new Set();
+  const IDENT = String.raw `(?:\[[^\]]+\]|"[^"]+"|` + '`[^`]+`' + String.raw `|[A-Za-z_#][\w#$]*)`;
+  const NAME = `(${IDENT}(?:\\s*\\.\\s*${IDENT})?)`;
+  const add = (text) => {
+    const parts = nameParts(text);
+    if (parts)
+      out.add(parts[parts.length - 1]);
+  };
+  const patterns = [
+    // VERTEX TABLE / EDGE TABLE first, or the name read would be TABLE
+    new RegExp(String.raw `^\s*CREATE\b[\s\S]*?\b(?:(?:VERTEX|EDGE)\s+TABLE|TABLE|CLASS|VIEW|VCLASS|VERTEX|EDGE|LABEL)\s+(?:IF\s+NOT\s+EXISTS\s+)?` + NAME, 'i'),
+    new RegExp(String.raw `^\s*ALTER\s+(?:\w+\s+)?(?:TABLE|CLASS|VIEW|VCLASS|VERTEX|EDGE|LABEL)\s+` + NAME, 'i'),
+    new RegExp(String.raw `^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:PROCEDURE|FUNCTION)\s+` + NAME, 'i'),
+    new RegExp(String.raw `^\s*CREATE\s+SERIAL\s+` + NAME, 'i'),
+    new RegExp(String.raw `^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:PUBLIC\s+|PRIVATE\s+)?SYNONYM\s+` + NAME, 'i'),
+  ];
+  for (const raw of statements) {
+    const sql = raw.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/(--|\/\/).*$/gm, ' ');
+    for (const re of patterns) {
+      const m = re.exec(sql);
+      if (m)
+        add(m[1]);
+    }
+    const rename = new RegExp(String.raw `^\s*RENAME\s+(?:TABLE\s+|CLASS\s+|VIEW\s+|VCLASS\s+)?` + NAME + String.raw `\s+(?:AS|TO)\s+` + NAME, 'i').exec(sql);
+    if (rename) {
+      add(rename[1]);
+      add(rename[2]);
+    }
+  }
+  return out;
+}
+// --- the check -----------------------------------------------------------------
+const named = (x) => x !== null && typeof x === 'object' && typeof x.name === 'string';
+const ownerOf = (o) => (typeof o.owner === 'string' ? o.owner : '').toLowerCase();
+/**
+ * The schema document's lists, indexed by lower-case name, with entries that
+ * have no name left out. validate() makes it once for all the statements of a
+ * text and passes it as `ctx.index`.
+ */
+export function indexSchema(schema) {
+  const byName = (list) => {
+    const map = new Map();
+    for (const x of Array.isArray(list) ? list : []) {
+      if (!named(x))
+        continue;
+      const key = x.name.toLowerCase();
+      map.set(key, [...(map.get(key) ?? []), x]);
+    }
+    return map;
+  };
+  return {
+    objects: byName(schema.objects),
+    synonyms: byName(schema.synonyms),
+    procedures: Array.isArray(schema.procedures) ? byName(schema.procedures) : null,
+    serials: Array.isArray(schema.serials) ? byName(schema.serials) : null,
+  };
+}
+/**
+ * Check the names in one statement the grammar accepted. `events` are the
+ * grammar's, their places in characters of `sql`.
+ */
+export function checkNames(sql, events, schema, ctx) {
+  // A trigger's statements use OBJ, NEW and OLD, which only the trigger defines.
+  if (/^\s*(?:CREATE|ALTER)\s+(?:OR\s+REPLACE\s+)?TRIGGER\b/i.test(sql.replace(/^(\s*(--|\/\/)[^\n]*\n|\s*\/\*[\s\S]*?\*\/)*/, ''))) {
+    return [];
+  }
+  // DROP … IF EXISTS asks for nothing to exist.
+  if (/^\s*DROP\b[^;]*?\bIF\s+EXISTS\b/i.test(sql)) {
+    return [];
+  }
+  const problems = [];
+  const created = ctx.created ?? new Set();
+  const backslashEscapes = Boolean(ctx.backslashEscapes);
+  const index = ctx.index ?? indexSchema(schema);
+  // The variables list_comp(x IN …), reduce(acc = …, x IN …) and similar bind: not columns.
+  const bound = new Set();
+  for (const m of sql.matchAll(/\breduce\s*\(\s*([A-Za-z_]\w*)\s*=/gi))
+    bound.add(m[1].toLowerCase());
+  for (const m of sql.matchAll(/[(,|]\s*([A-Za-z_]\w*)\s+IN\s+(?=[\w.]+\s*\(|\{|[\w.]+\s*\|)/gi))
+    bound.add(m[1].toLowerCase());
+  const report = (start, end, message) => {
+    if (!problems.some((p) => p.start === start && p.message === message))
+      problems.push({ start, end, message });
+  };
+  const textOf = (e) => sql.slice(e.start, e.end);
+  const isSystem = (name) => name.startsWith('db_') || name.startsWith('_db_') || name === 'dual';
+  const ctes = new Set(events.filter((e) => e.kind === EV.CTE).map((e) => nameParts(textOf(e))?.[0] ?? ''));
+  /**
+   * What a table name means: its objects, or lenient, or a problem to report.
+   * `via` holds the synonyms followed to get here: a synonym that leads back
+   * to itself explains nothing, and is let through.
+   */
+  const lookup = (parts, via = new Set()) => {
+    if (parts.length > 2)
+      return { objects: [], lenient: true, missing: false };
+    const name = parts[parts.length - 1];
+    const owner = parts.length === 2 ? parts[0] : null;
+    if ((owner === null && ctes.has(name)) || created.has(name) || isSystem(name)) {
+      return { objects: [], lenient: true, missing: false };
+    }
+    const found = (index.objects.get(name) ?? []).filter((o) => owner === null || ownerOf(o) === owner);
+    if (found.length > 0)
+      return { objects: found, lenient: false, missing: false };
+    const syn = (index.synonyms.get(name) ?? []).find((s) => owner === null || ownerOf(s) === owner);
+    if (syn) {
+      const target = typeof syn.target === 'string' && !via.has(syn) ? nameParts(syn.target) : null;
+      if (target) {
+        const t = lookup(target, new Set([...via, syn]));
+        if (!t.missing)
+          return t;
+      }
+      return { objects: [], lenient: true, missing: false };
+    }
+    return { objects: [], lenient: false, missing: true };
+  };
+  /** The columns of an object, the ones it inherits included; null when one of its parents is not known. */
+  const columnsCache = new Map();
+  const columnsOf = (o, seen = new Set()) => {
+    if (columnsCache.has(o))
+      return columnsCache.get(o) ?? null;
+    if (seen.has(o))
+      return new Set();
+    seen.add(o);
+    if (!Array.isArray(o.columns)) {
+      columnsCache.set(o, null);
+      return null;
+    }
+    const cols = new Set(o.columns.filter(named).map((c) => c.name.toLowerCase()));
+    for (const parent of Array.isArray(o.under) ? o.under : []) {
+      const p = typeof parent === 'string' ? nameParts(parent) : null;
+      const found = p ? lookup(p) : null;
+      if (!found || found.objects.length === 0) {
+        columnsCache.set(o, null);
+        return null;
+      }
+      for (const po of found.objects) {
+        const pc = columnsOf(po, seen);
+        if (pc === null) {
+          columnsCache.set(o, null);
+          return null;
+        }
+        for (const c of pc)
+          cols.add(c);
+      }
+    }
+    columnsCache.set(o, cols);
+    return cols;
+  };
+  const bindingHas = (b, col) => {
+    if (b.lenient)
+      return null;
+    let unknown = false;
+    for (const o of b.objects) {
+      const cols = columnsOf(o);
+      if (cols === null)
+        unknown = true;
+      else if (cols.has(col))
+        return true;
+    }
+    return unknown ? null : false;
+  };
+  // --- scopes ---
+  const scopes = events
+    .filter((e) => SCOPE_KINDS.has(e.kind))
+    .map((e) => ({
+    kind: e.kind,
+    start: e.start,
+    end: e.end,
+    parent: null,
+    bindings: [],
+    aliases: new Set(),
+    natural: /\bNATURAL\b/i.test(textOf(e)),
+  }));
+  // Smallest first; of two with the same text, the SELECT is inside the QUERY.
+  scopes.sort((a, b) => a.end - a.start - (b.end - b.start) || (a.kind === EV.QUERY ? 1 : 0) - (b.kind === EV.QUERY ? 1 : 0));
+  const contains = (outer, s, e) => outer.start <= s && e <= outer.end;
+  for (let i = 0; i < scopes.length; i += 1) {
+    for (let j = i + 1; j < scopes.length; j += 1) {
+      if (contains(scopes[j], scopes[i].start, scopes[i].end)) {
+        scopes[i].parent = scopes[j];
+        break;
+      }
+    }
+  }
+  const scopeAt = (s, e) => scopes.find((sc) => contains(sc, s, e)) ?? null;
+  // --- what each FROM, MATCH and INSERT brings into its scope ---
+  const tableChecked = new Set();
+  const bindTable = (e, scope, kindWanted) => {
+    const parts = nameParts(textOf(e));
+    if (!parts)
+      return null;
+    const found = lookup(parts);
+    const name = parts[parts.length - 1];
+    if (found.missing && !tableChecked.has(e.start)) {
+      tableChecked.add(e.start);
+      const what = kindWanted === 'node' ? 'node class' : kindWanted === 'edge' ? 'edge class' : 'table or view';
+      report(e.start, e.end, `There is no ${what} named ${name}.`);
+    }
+    let wrongKind = false;
+    if (kindWanted && found.objects.length > 0 && !found.objects.some((o) => o.kind === kindWanted)) {
+      wrongKind = true;
+      if (!tableChecked.has(e.start)) {
+        tableChecked.add(e.start);
+        report(e.start, e.end, `${name} is not ${kindWanted === 'node' ? 'a node' : 'an edge'} class.`);
+      }
+    }
+    const b = {
+      names: [name, ...(parts.length === 2 ? [parts.join('.')] : [])],
+      objects: found.objects,
+      lenient: found.lenient || found.missing || wrongKind,
+      label: name,
+    };
+    if (scope)
+      scope.bindings.push(b);
+    return b;
+  };
+  for (let i = 0; i < events.length; i += 1) {
+    const e = events[i];
+    if (e.kind === EV.TSPEC) {
+      const scope = scopeAt(e.start, e.end);
+      const tables = events.filter((t) => t.kind === EV.TABLE && t.start >= e.start && t.end <= e.end);
+      const aliasEv = events[i + 1]?.kind === EV.TALIAS ? events[i + 1] : null;
+      const alias = aliasEv ? aliasOf(textOf(aliasEv)) : null;
+      if (tables.length === 1) {
+        const b = bindTable(tables[0], null);
+        if (b && scope) {
+          if (alias) {
+            b.names.unshift(alias.name);
+            if (alias.renames)
+              b.lenient = true;
+          }
+          scope.bindings.push(b);
+        }
+      }
+      else {
+        for (const t of tables)
+          bindTable(t, null);
+        if (scope && alias)
+          scope.bindings.push({ names: [alias.name], objects: [], lenient: true, label: alias.name });
+      }
+    }
+    else if (e.kind === EV.DALIAS) {
+      const alias = aliasOf(textOf(e));
+      const scope = scopeAt(e.start, e.end);
+      if (alias && scope)
+        scope.bindings.push({ names: [alias.name], objects: [], lenient: true, label: alias.name });
+    }
+    else if (e.kind === EV.NODE_VAR && events[i + 1]?.kind === EV.NODE_LABEL) {
+      const label = events[i + 1];
+      const v = nameParts(textOf(e));
+      const scope = scopeAt(e.start, e.end);
+      const b = bindTable(label, null, 'node');
+      if (b && v && v.length === 1) {
+        b.names = [v[0]];
+        scope?.bindings.push(b);
+      }
+    }
+    else if (e.kind === EV.EDGE_LABELS) {
+      const varEv = events[i - 1]?.kind === EV.EDGE_VAR ? events[i - 1] : null;
+      const v = varEv ? nameParts(textOf(varEv)) : null;
+      const scope = scopeAt(e.start, e.end);
+      const objects = [];
+      let lenient = false;
+      let pos = e.start;
+      for (const piece of textOf(e).split('|')) {
+        const lead = piece.length - piece.trimStart().length;
+        const b = bindTable({ kind: EV.TABLE, start: pos + lead, end: pos + lead + piece.trim().length }, null, 'edge');
+        if (b) {
+          objects.push(...b.objects);
+          lenient || (lenient = b.lenient);
+        }
+        else
+          lenient = true;
+        pos += piece.length + 1;
+      }
+      if (v && v.length === 1 && scope)
+        scope.bindings.push({ names: [v[0]], objects, lenient, label: v[0] });
+    }
+    else if (e.kind === EV.INS_TARGET || e.kind === EV.INS_VERTEX || e.kind === EV.INS_EDGE) {
+      const scope = scopeAt(e.start, e.end);
+      bindTable(e, scope, e.kind === EV.INS_VERTEX ? 'node' : e.kind === EV.INS_EDGE ? 'edge' : undefined);
+    }
+    else if (e.kind === EV.SELECT_ALIAS) {
+      const alias = aliasOf(textOf(e));
+      const scope = scopeAt(e.start, e.end);
+      if (alias && scope)
+        scope.aliases.add(alias.name);
+    }
+  }
+  // Tables named anywhere else a table spec reaches (UPDATE, DELETE, MERGE) are
+  // all bound through TSPEC above; any left over are still checked.
+  for (const e of events) {
+    if (e.kind === EV.TABLE && !tableChecked.has(e.start)) {
+      const parts = nameParts(textOf(e));
+      if (parts && lookup(parts).missing) {
+        tableChecked.add(e.start);
+        report(e.start, e.end, `There is no table or view named ${parts[parts.length - 1]}.`);
+      }
+    }
+  }
+  // --- columns ---
+  /** The bindings a reference in `scope` sees there: a QUERY's are those of its SELECTs (for ORDER BY). */
+  const visible = (scope) => {
+    if (scope.kind !== EV.QUERY)
+      return { bindings: scope.bindings, aliases: scope.aliases };
+    const bindings = [...scope.bindings];
+    const aliases = new Set(scope.aliases);
+    for (const s of scopes) {
+      if (s.parent === scope && s.kind === EV.SELECT) {
+        bindings.push(...s.bindings);
+        for (const a of s.aliases)
+          aliases.add(a);
+      }
+    }
+    return { bindings, aliases };
+  };
+  const chain = (scope) => {
+    const out = [];
+    for (let s = scope; s; s = s.parent)
+      out.push(s);
+    return out;
+  };
+  const findBinding = (scopesUp, name) => {
+    for (const s of scopesUp) {
+      const b = visible(s).bindings.find((x) => x.names.includes(name));
+      if (b)
+        return b;
+    }
+    return null;
+  };
+  const SERIAL_PARTS = new Set(['next_value', 'current_value']);
+  const serialKnown = (parts) => {
+    if (!index.serials)
+      return true;
+    const name = parts[parts.length - 1];
+    if (created.has(name))
+      return true;
+    const owner = parts.length === 2 ? parts[0] : null;
+    return (index.serials.get(name) ?? []).some((s) => owner === null || ownerOf(s) === owner);
+  };
+  for (const e of events) {
+    if (e.kind !== EV.COLUMN && e.kind !== EV.STAR_QUALIFIER)
+      continue;
+    const text = textOf(e);
+    // Not a plain column: a call, a parameter, a CLASS reference, a set element.
+    if (/[({]|->/.test(text) || /^\s*[:?]/.test(text) || /^\s*CLASS\s/i.test(text))
+      continue;
+    const parts = nameParts(text);
+    if (!parts)
+      continue;
+    if (bound.has(parts[0]))
+      continue;
+    const scope = scopeAt(e.start, e.end);
+    if (!scope)
+      continue;
+    const up = chain(scope);
+    if (e.kind === EV.STAR_QUALIFIER) {
+      const q = parts.join('.');
+      if (!findBinding(up, q) && !findBinding(up, parts[parts.length - 1])) {
+        report(e.start, e.end, `There is no table or alias named ${parts.join('.')} in this query.`);
+      }
+      continue;
+    }
+    if (parts.length === 1) {
+      const col = parts[0];
+      let found = false;
+      for (const s of up) {
+        const { bindings, aliases } = visible(s);
+        if (aliases.has(col) || bindings.some((b) => b.names.includes(col))) {
+          found = true;
+          break;
+        }
+        if (bindings.some((b) => bindingHas(b, col) === null)) {
+          found = true;
+          break;
+        }
+        const having = bindings.filter((b) => bindingHas(b, col) === true);
+        if (having.length > 0) {
+          found = true;
+          const distinct = [...new Set(having)];
+          if (distinct.length > 1 && !s.natural && s.kind !== EV.QUERY) {
+            const labels = distinct.map((b) => b.label);
+            const who = `${labels.slice(0, -1).join(', ')} and ${labels[labels.length - 1]}`;
+            report(e.start, e.end, `Column ${col} is ambiguous: ${who} ${labels.length === 2 ? 'both' : 'all'} have it.`);
+          }
+          break;
+        }
+      }
+      if (!found) {
+        const tables = [...new Set(up.flatMap((s) => visible(s).bindings))];
+        report(e.start, e.end, tables.length === 0
+          ? `There is no column named ${col}: the query reads no table.`
+          : tables.length === 1
+            ? `${tables[0].label} has no column named ${col}.`
+            : `None of the tables in this query has a column named ${col}.`);
+      }
+      continue;
+    }
+    // q.c, owner.table.c, serial.NEXT_VALUE, column.attribute (a path)
+    const tryQualified = (q, col) => {
+      const b = findBinding(up, q);
+      if (!b)
+        return false;
+      const has = bindingHas(b, col);
+      if (has === false)
+        report(e.start, e.end, `${b.label} has no column named ${col}.`);
+      return true;
+    };
+    if (parts.length >= 3 && tryQualified(`${parts[0]}.${parts[1]}`, parts[2]))
+      continue;
+    if (tryQualified(parts[0], parts[1]))
+      continue;
+    if (SERIAL_PARTS.has(parts[parts.length - 1])) {
+      const serial = parts.slice(0, -1);
+      if (serial.length <= 2 && !serialKnown(serial)) {
+        report(e.start, e.end, `There is no serial named ${serial[serial.length - 1]}.`);
+      }
+      continue;
+    }
+    // A column whose value is an object: its attributes are read through it.
+    const asColumn = up.some((s) => visible(s).bindings.some((b) => bindingHas(b, parts[0]) !== false));
+    if (asColumn || parts.length >= 3)
+      continue;
+    report(e.start, e.end, `There is no table or alias named ${parts[0]} in this query.`);
+  }
+  // --- INSERT: its columns and how many values each row has ---
+  for (const scope of scopes) {
+    if (scope.kind !== EV.INSERT)
+      continue;
+    const target = scope.bindings[0];
+    if (!target)
+      continue;
+    const inScope = (e) => scopeAt(e.start, e.end) === scope;
+    const colsEv = events.find((e) => e.kind === EV.INS_COLS && inScope(e));
+    const listed = colsEv ? listedNames(textOf(colsEv), colsEv.start) : [];
+    const listedText = colsEv ? textOf(colsEv).trim() : '';
+    for (const c of listed) {
+      if (bindingHas(target, c.name) === false)
+        report(c.start, c.end, `${target.label} has no column named ${c.name}.`);
+    }
+    for (const e of events) {
+      if (e.kind === EV.INS_SETCOL && inScope(e)) {
+        const p = nameParts(textOf(e));
+        if (p && bindingHas(target, p[p.length - 1]) === false) {
+          report(e.start, e.end, `${target.label} has no column named ${p[p.length - 1]}.`);
+        }
+      }
+    }
+    let expected = null;
+    let against = '';
+    if (listedText !== '') {
+      expected = listed.length;
+      against = plural(expected, 'column');
+    }
+    else if (!target.lenient && target.objects.length === 1) {
+      const o = target.objects[0];
+      if ((o.kind === 'table' || o.kind === 'view') && !(Array.isArray(o.under) && o.under.length) && Array.isArray(o.columns)) {
+        expected = o.columns.length;
+        against = `the ${plural(expected, 'column')} of ${target.label}`;
+      }
+    }
+    if (expected === null)
+      continue;
+    for (const e of events) {
+      if ((e.kind !== EV.INS_ROW && e.kind !== EV.INS_ROW_EMPTY) || !inScope(e))
+        continue;
+      const count = e.kind === EV.INS_ROW_EMPTY ? 0 : countItems(textOf(e), backslashEscapes);
+      if (count !== expected) {
+        report(e.start, e.end, `${plural(count, 'value')} for ${against}.`);
+      }
+    }
+  }
+  // --- functions and procedures ---
+  const procedures = index.procedures;
+  const findProcedure = (name) => procedures?.get(name)?.[0];
+  const calls = events.filter((e) => e.kind === EV.CALL);
+  for (let i = 0; i < events.length; i += 1) {
+    const e = events[i];
+    if (e.kind !== EV.FUNC_NAME)
+      continue;
+    const argsEv = events[i + 1]?.kind === EV.FUNC_ARGS ? events[i + 1] : null;
+    const targetEv = events[i + 2]?.kind === EV.FUNC_TARGET ? events[i + 2] : null;
+    if (targetEv && textOf(targetEv).trim() !== '')
+      continue; // a method, ON its object
+    // obj.method(), owner.function(): not looked up.
+    if (/\.\s*$/.test(sql.slice(0, e.start)))
+      continue;
+    const parts = nameParts(textOf(e));
+    if (!parts || parts.length !== 1)
+      continue;
+    const name = parts[0];
+    const argc = argsEv ? countItems(textOf(argsEv), backslashEscapes) : 0;
+    const proc = findProcedure(name);
+    const mask = ctx.builtin(name);
+    if (mask !== -2) {
+      const allowed = mask === -1 || (argc <= 29 ? (mask & (1 << argc)) !== 0 : (mask & (1 << 30)) !== 0);
+      if (!allowed && !proc) {
+        const words = countWords(mask);
+        report(e.start, e.end, `${name.toUpperCase()} takes ${words} ${words === '1' ? 'argument' : 'arguments'}, not ${argc}.`);
+      }
+      continue;
+    }
+    if (!procedures || created.has(name))
+      continue;
+    if (!proc) {
+      report(e.start, e.end, `There is no function or procedure named ${name}.`);
+      continue;
+    }
+    if (Array.isArray(proc.params) && proc.params.length !== argc) {
+      report(e.start, e.end, `${proc.name} takes ${plural(proc.params.length, 'argument')}, not ${argc}.`);
+    }
+    const called = calls.some((c) => {
+      const after = sql.slice(c.start, c.end).match(/^\s*CALL\s+/i);
+      return after !== null && c.start + after[0].length === e.start;
+    });
+    if (!called && proc.kind === 'procedure') {
+      report(e.start, e.end, `${proc.name} is a procedure: run it with CALL; it has no value to use here.`);
+    }
+  }
+  return problems.sort((a, b) => a.start - b.start);
+}