@tablecraft-app/plugin-api 0.0.0-stage → 1.2.0

package/dist/sql/format.js

@@ -0,0 +1,117 @@
+import { formatDialect, mysql, plsql, postgresql, sqlite, transactsql, } from "sql-formatter";
+import { formatAligned } from "./layout.js";
+import { Lexer, separatorLineAt, wordOf } from "./tokens.js";
+/** The `sql-formatter` dialects plugins may name (decisions 042 and 100). */
+export const FORMAT_DIALECTS = { postgresql, mysql, sqlite, plsql, transactsql };
+const DELIMITER_COMMAND = "DELIMITER";
+const DELIMITER_REFUSAL = "a DELIMITER line changes what ends a statement; reformat the statements between them.";
+const SEPARATOR_REFUSAL = "a batch separator line splits the script; reformat the batches between them.";
+const UNREADABLE = "the text is not SQL the formatter can read.";
+const NAMED_PREFIX = ":";
+const NUMBERED_PREFIX = "$";
+const BLOCK_COMMENT_OPEN = "/*";
+const STAND_IN_TAG = "table_craft_comment_";
+function paramTypes(styles) {
+    return {
+        named: styles.includes("named") ? [NAMED_PREFIX] : [],
+        numbered: styles.includes("numbered") ? [NUMBERED_PREFIX] : [],
+        positional: styles.includes("positional"),
+    };
+}
+function startsALine(text, from) {
+    const lineStart = text.lastIndexOf("\n", from - 1) + 1;
+    return text.slice(lineStart, from).trim() === "";
+}
+function hasDelimiterCommand(text, dialect) {
+    const lexer = new Lexer(text, dialect);
+    for (let token = lexer.next(); token !== null; token = lexer.next()) {
+        if (token.kind === "word" && wordOf(text, token) === DELIMITER_COMMAND && startsALine(text, token.from))
+            return true;
+    }
+    return false;
+}
+function hasSeparatorLine(text, dialect) {
+    const separator = dialect.batchSeparator;
+    if (separator === undefined)
+        return false;
+    const lexer = new Lexer(text, dialect);
+    for (let token = lexer.next(); token !== null; token = lexer.next()) {
+        if (separatorLineAt(text, token, separator) !== null)
+            return true;
+    }
+    return false;
+}
+/**
+ * The library re-indents the continuation lines of a block comment. Each multi-line one goes in as
+ * a one-line stand-in, which it leaves alone, and comes back as written.
+ */
+function shieldBlockComments(text, dialect) {
+    const lexer = new Lexer(text, dialect);
+    const comments = [];
+    let shielded = "";
+    let at = 0;
+    let salt = 0;
+    while (text.includes(standIn(salt, 0)))
+        salt += 1;
+    for (let token = lexer.next(); token !== null; token = lexer.next()) {
+        const content = text.slice(token.from, token.to);
+        if (token.kind !== "comment" || !content.startsWith(BLOCK_COMMENT_OPEN) || !content.includes("\n"))
+            continue;
+        shielded += text.slice(at, token.from) + standIn(salt, comments.length);
+        comments.push(content);
+        at = token.to;
+    }
+    if (comments.length === 0)
+        return { text, restore: (formatted) => formatted };
+    return {
+        text: shielded + text.slice(at),
+        restore: (formatted) => comments.reduce((result, comment, index) => result.replace(standIn(salt, index), () => comment), formatted),
+    };
+}
+function standIn(salt, index) {
+    return `/*${STAND_IN_TAG}${String(salt)}_${String(index)}*/`;
+}
+/** The library's parse errors run to a page of grammar; the first line says where. */
+function reasonOf(cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    const firstLine = message.split("\n", 1)[0]?.trim() ?? "";
+    return firstLine === "" ? UNREADABLE : firstLine;
+}
+/**
+ * `SqlLanguage.format`: the aligned layout (decision 061) or `sql-formatter`'s (decision 042), which
+ * also takes every statement the aligned one does not read (decision 062). Throws an `Error` with a
+ * one-line reason rather than returning half-formatted text; comments and literals pass through as
+ * written.
+ */
+export function sqlFormatter(options) {
+    const dialect = FORMAT_DIALECTS[options.dialect];
+    const params = paramTypes(options.parameters);
+    const standard = (text, format) => {
+        const shielded = shieldBlockComments(text, options.lexer);
+        try {
+            return shielded.restore(formatDialect(shielded.text, {
+                dialect,
+                keywordCase: format.keywordCase,
+                dataTypeCase: format.keywordCase,
+                tabWidth: format.indentWidth,
+                linesBetweenQueries: format.linesBetweenStatements,
+                paramTypes: params,
+            }));
+        }
+        catch (cause) {
+            throw new Error(reasonOf(cause), { cause });
+        }
+    };
+    return {
+        format(text, format) {
+            if (options.lexer.delimiterCommand === true && hasDelimiterCommand(text, options.lexer)) {
+                throw new Error(DELIMITER_REFUSAL);
+            }
+            if (hasSeparatorLine(text, options.lexer))
+                throw new Error(SEPARATOR_REFUSAL);
+            if (format.style === "standard")
+                return standard(text, format);
+            return formatAligned(text, format, options.lexer, (statement) => standard(statement, format));
+        },
+    };
+}

package/dist/sql/functions.d.ts

@@ -0,0 +1,47 @@
+import type { CompletionItem, FunctionSignature } from "@tablecraft-app/plugin-api";
+/** Where a function belongs in the server's manual; it groups the data, the popup does not show it. */
+export declare const FUNCTION_CATEGORIES: readonly ["string", "numeric", "datetime", "json", "aggregate", "window", "information", "encryption", "locking", "spatial", "xml", "control", "misc", "server"];
+export type FunctionCategory = (typeof FUNCTION_CATEGORIES)[number];
+/**
+ * The versions of each server flavour a function exists in: space-separated comparators all of which
+ * hold, such as `">=5.7.22 <8.0"`, or `false` for none. A flavour it does not name has it in every
+ * version (decision 097).
+ */
+export type ServerRange = Readonly<Record<string, string | false>>;
+/** A server as completion reads it: the plugin's name for its flavour and the version in it. */
+export interface ServerIdentity {
+    readonly flavour: string;
+    readonly version: readonly number[];
+}
+/** A built-in function a plugin documents (decision 097). */
+export interface FunctionSpec {
+    /** As the manual writes it, upper case; the popup offers it lower case. */
+    readonly name: string;
+    readonly signatures: readonly FunctionSignature[];
+    readonly summary: string;
+    readonly category: FunctionCategory;
+    readonly available?: ServerRange;
+}
+/** `[name, signatures, summary, available?]`, a signature written `"date, format -> string"`. */
+export type FunctionEntry = readonly [
+    name: string,
+    signatures: string | readonly string[],
+    summary: string,
+    available?: ServerRange
+];
+/** Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats. */
+export declare function parseSignature(written: string): FunctionSignature;
+/** Specs for one category, from compact entries a plugin's data file lists. */
+export declare function functionSpecs(category: FunctionCategory, entries: readonly FunctionEntry[]): FunctionSpec[];
+/** Whether `spec` exists on `server`; an unknown server has every function any flavour has. */
+export declare function isAvailable(spec: FunctionSpec, server: ServerIdentity | null): boolean;
+/** `(date, format) → string`, the popup's detail for one signature. */
+export declare function signatureLabel(signature: FunctionSignature): string;
+/** Every signature on its own line, then the summary. */
+export declare function functionInfo(spec: FunctionSpec): string;
+/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments. */
+export declare function functionItem(spec: FunctionSpec | string, boost: number): CompletionItem;
+/** The name a function entry is offered under, either form. */
+export declare function functionName(spec: FunctionSpec | string): string;
+/** Aggregate and scalar functions every built-in dialect has; a plugin adds its own. Written in our own words. */
+export declare const SQL_FUNCTIONS: readonly FunctionSpec[];

package/dist/sql/functions.js

@@ -0,0 +1,159 @@
+/** Where a function belongs in the server's manual; it groups the data, the popup does not show it. */
+export const FUNCTION_CATEGORIES = [
+    "string",
+    "numeric",
+    "datetime",
+    "json",
+    "aggregate",
+    "window",
+    "information",
+    "encryption",
+    "locking",
+    "spatial",
+    "xml",
+    "control",
+    "misc",
+    "server",
+];
+const RETURNS_ARROW = "->";
+const SHOWN_ARROW = "→";
+const OPTIONAL_MARK = "?";
+const VARIADIC_MARK = "...";
+const COMPARATOR = /^(>=|<=|>|<|=)?(\d+(?:\.\d+)*)$/;
+function parameter(written) {
+    let name = written.trim();
+    const variadic = name.endsWith(VARIADIC_MARK);
+    if (variadic)
+        name = name.slice(0, -VARIADIC_MARK.length).trim();
+    const optional = name.endsWith(OPTIONAL_MARK);
+    if (optional)
+        name = name.slice(0, -OPTIONAL_MARK.length).trim();
+    return { name, ...(optional ? { optional } : {}), ...(variadic ? { variadic } : {}) };
+}
+/** Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats. */
+export function parseSignature(written) {
+    const arrow = written.lastIndexOf(RETURNS_ARROW);
+    if (arrow < 0)
+        throw new Error(`Signature "${written}" has no "${RETURNS_ARROW} type"; add what it returns.`);
+    const list = written.slice(0, arrow).trim();
+    return {
+        parameters: list === "" ? [] : list.split(",").map(parameter),
+        returns: written.slice(arrow + RETURNS_ARROW.length).trim(),
+    };
+}
+/** Specs for one category, from compact entries a plugin's data file lists. */
+export function functionSpecs(category, entries) {
+    return entries.map(([name, signatures, summary, available]) => ({
+        name,
+        signatures: (typeof signatures === "string" ? [signatures] : signatures).map(parseSignature),
+        summary,
+        category,
+        ...(available === undefined ? {} : { available }),
+    }));
+}
+function compareVersions(left, right) {
+    for (let at = 0; at < Math.max(left.length, right.length); at += 1) {
+        const difference = (left[at] ?? 0) - (right[at] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}
+function satisfies(version, comparator) {
+    const match = COMPARATOR.exec(comparator);
+    if (match === null)
+        throw new Error(`Version comparator "${comparator}" is not like ">=8.0.4"; fix the range.`);
+    const order = compareVersions(version, (match[2] ?? "").split(".").map(Number));
+    switch (match[1]) {
+        case ">=":
+            return order >= 0;
+        case "<=":
+            return order <= 0;
+        case ">":
+            return order > 0;
+        case "<":
+            return order < 0;
+        default:
+            return order === 0;
+    }
+}
+/** Whether `spec` exists on `server`; an unknown server has every function any flavour has. */
+export function isAvailable(spec, server) {
+    if (spec.available === undefined || server === null)
+        return true;
+    const range = spec.available[server.flavour];
+    if (range === undefined)
+        return true;
+    if (range === false)
+        return false;
+    return range
+        .split(/\s+/)
+        .filter((comparator) => comparator !== "")
+        .every((comparator) => satisfies(server.version, comparator));
+}
+function shownParameter(parameter) {
+    const name = parameter.variadic === true ? `${parameter.name}${VARIADIC_MARK}` : parameter.name;
+    return parameter.optional === true ? `[${name}]` : name;
+}
+/** `(date, format) → string`, the popup's detail for one signature. */
+export function signatureLabel(signature) {
+    return `(${signature.parameters.map(shownParameter).join(", ")}) ${SHOWN_ARROW} ${signature.returns}`;
+}
+/** Every signature on its own line, then the summary. */
+export function functionInfo(spec) {
+    const label = spec.name.toLowerCase();
+    const lines = spec.signatures.map((signature) => `${label}${signatureLabel(signature)}`);
+    return `${lines.join("\n")}\n\n${spec.summary}`;
+}
+/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments. */
+export function functionItem(spec, boost) {
+    if (typeof spec === "string")
+        return { label: spec, kind: "function", detail: null, apply: spec, boost, info: null, caret: null };
+    const label = spec.name.toLowerCase();
+    const first = spec.signatures[0];
+    const takesArguments = spec.signatures.some((signature) => signature.parameters.length > 0);
+    return {
+        label,
+        kind: "function",
+        detail: first === undefined ? null : signatureLabel(first),
+        apply: `${label}()`,
+        boost,
+        info: functionInfo(spec),
+        caret: takesArguments ? label.length + 1 : null,
+    };
+}
+/** The name a function entry is offered under, either form. */
+export function functionName(spec) {
+    return typeof spec === "string" ? spec : spec.name;
+}
+/** Aggregate and scalar functions every built-in dialect has; a plugin adds its own. Written in our own words. */
+export const SQL_FUNCTIONS = [
+    ...functionSpecs("aggregate", [
+        ["AVG", "expr -> number", "The mean of the non-null values in the group."],
+        ["COUNT", ["* -> integer", "expr -> integer"], "How many rows the group has, or how many give a non-null value."],
+        ["MAX", "expr -> value", "The largest value in the group."],
+        ["MIN", "expr -> value", "The smallest value in the group."],
+        ["SUM", "expr -> number", "The total of the values in the group."],
+    ]),
+    ...functionSpecs("numeric", [
+        ["ABS", "x -> number", "The value without its sign."],
+        ["ROUND", "x, digits? -> number", "Rounds to the given number of decimal places, zero by default."],
+    ]),
+    ...functionSpecs("string", [
+        ["LENGTH", "str -> integer", "How long the string is."],
+        ["LOWER", "str -> string", "The string in lower case."],
+        ["REPLACE", "str, from, to -> string", "Swaps every occurrence of one substring for another."],
+        [
+            "SUBSTR",
+            "str, start, length? -> string",
+            "Part of the string from a 1-based position, optionally of a set length.",
+        ],
+        ["TRIM", "str -> string", "The string without spaces at either end."],
+        ["UPPER", "str -> string", "The string in upper case."],
+    ]),
+    ...functionSpecs("control", [
+        ["CAST", "expr AS type -> value", "Converts a value to another type."],
+        ["COALESCE", "value... -> value", "The first argument that is not null."],
+        ["NULLIF", "a, b -> value", "Null when both arguments are equal, else the first."],
+    ]),
+];

package/dist/sql/generate.d.ts

@@ -0,0 +1,22 @@
+import type { ImportKind, InferredColumn, SqlLanguage } from "@tablecraft-app/plugin-api";
+/** What the shared generator needs to know about a dialect (decision 029). */
+export interface GeneratorOptions {
+    readonly quoteIdentifier: (name: string) => string;
+    readonly updateDefault: (defaultExpression: string | null) => string;
+    /** A name the dialect reads back unchanged without quotes; any other is quoted. */
+    readonly plainIdentifier: RegExp;
+    /** A name that spells one of these is quoted. Upper case. */
+    readonly keywords: readonly string[];
+}
+/** The completer's rule, so a generated statement spells a name as completion inserts it. */
+export declare function identifierWriter(options: Omit<GeneratorOptions, "updateDefault">): (identifier: string) => string;
+/** DROP, SELECT, INSERT and UPDATE for a catalog relation, which every built-in plugin spreads into its `SqlLanguage`. */
+export declare function sqlGenerator(options: GeneratorOptions): Pick<SqlLanguage, "generate">;
+/** What `sqlImporter` needs: the generator's naming rule, and the dialect's column type per inferred kind. */
+export interface ImporterOptions extends Omit<GeneratorOptions, "updateDefault"> {
+    /** The type for a kind; `decimal` also gets the sample's digits, so a dialect can size it. */
+    readonly types: Readonly<Record<Exclude<ImportKind, "decimal">, string>>;
+    readonly decimal: (column: InferredColumn) => string;
+}
+/** `importType` and `createTable` for a plugin that declares `bulkInsert` (decision 046). */
+export declare function sqlImporter(options: ImporterOptions): Required<Pick<SqlLanguage, "importType" | "createTable">>;

package/dist/sql/generate.js

@@ -0,0 +1,64 @@
+const NULL = "NULL";
+const INDENT = "  ";
+const DROP_KEYWORDS = {
+    table: "DROP TABLE",
+    view: "DROP VIEW",
+    materializedView: "DROP MATERIALIZED VIEW",
+};
+/** The completer's rule, so a generated statement spells a name as completion inserts it. */
+export function identifierWriter(options) {
+    const reserved = new Set(options.keywords.map((keyword) => keyword.toUpperCase()));
+    return (identifier) => options.plainIdentifier.test(identifier) && !reserved.has(identifier.toUpperCase())
+        ? identifier
+        : options.quoteIdentifier(identifier);
+}
+/** DROP, SELECT, INSERT and UPDATE for a catalog relation, which every built-in plugin spreads into its `SqlLanguage`. */
+export function sqlGenerator(options) {
+    const name = identifierWriter(options);
+    function list(columns) {
+        return columns.map((column) => name(column.name)).join(", ");
+    }
+    function insertValue(column) {
+        return column.default === null ? NULL : options.updateDefault(column.default);
+    }
+    function update(relation, qualifiedName) {
+        const keyNames = new Set(relation.primaryKey?.columns ?? []);
+        const keyed = keyNames.size > 0;
+        const unkeyed = relation.columns.filter((column) => !keyNames.has(column.name));
+        // A table that is all key still needs a SET, so the key columns fill it.
+        const set = unkeyed.length > 0 ? unkeyed : relation.columns;
+        const where = keyed ? relation.columns.filter((column) => keyNames.has(column.name)) : relation.columns;
+        return [
+            `UPDATE ${qualifiedName}`,
+            `SET ${set.map((column) => `${name(column.name)} = ${NULL}`).join(`,\n${INDENT}${INDENT}`)}`,
+            `WHERE ${where.map((column) => `${name(column.name)} = ${NULL}`).join(`\n${INDENT}AND `)};`,
+        ].join("\n");
+    }
+    return {
+        generate(statement, relation, qualifiedName) {
+            switch (statement) {
+                case "drop":
+                    return `${DROP_KEYWORDS[relation.kind]} ${qualifiedName};`;
+                case "select":
+                    return `SELECT ${list(relation.columns)}\nFROM ${qualifiedName};`;
+                case "insert": {
+                    const assigned = relation.columns.filter((column) => !column.autoIncrement);
+                    const columns = assigned.length > 0 ? assigned : relation.columns;
+                    return `INSERT INTO ${qualifiedName} (${list(columns)})\nVALUES (${columns.map(insertValue).join(", ")});`;
+                }
+                case "update":
+                    return update(relation, qualifiedName);
+            }
+        },
+    };
+}
+/** `importType` and `createTable` for a plugin that declares `bulkInsert` (decision 046). */
+export function sqlImporter(options) {
+    const name = identifierWriter(options);
+    return {
+        importType: (column) => (column.kind === "decimal" ? options.decimal(column) : options.types[column.kind]),
+        createTable: (qualifiedName, columns) => `CREATE TABLE ${qualifiedName} (\n${columns
+            .map((column) => `${INDENT}${name(column.name)} ${column.type}`)
+            .join(",\n")}\n);`,
+    };
+}

package/dist/sql/index.d.ts

@@ -0,0 +1,16 @@
+export { SQL_KEYWORDS, sqlCompleter, type CompleterOptions, type IdentifierFolding } from "./complete.js";
+export { sqlInspector, type InspectorOptions } from "./inspect.js";
+export { FUNCTION_CATEGORIES, functionInfo, functionItem, functionSpecs, isAvailable, parseSignature, signatureLabel, SQL_FUNCTIONS, type FunctionCategory, type FunctionEntry, type FunctionSpec, type ServerIdentity, type ServerRange, } from "./functions.js";
+export { callAt, type CallAt } from "./signature.js";
+export { classifyTokens, EXPLAIN_ANALYZE_REASON_PREFIX, transactionEffect, type TransactionEffect, } from "./classify.js";
+export { FORMAT_DIALECTS, sqlFormatter, type FormatDialect, type FormatterOptions } from "./format.js";
+export { sqlParameters, type NativePlaceholder, type ParameterOptions } from "./parameters.js";
+export { sqlSplitter, sqlStatementStream } from "./splitter.js";
+export { parseSimpleSelect, SELECT_READ_ONLY_REASONS, type SimpleSelect, type SimpleSelectItem } from "./select.js";
+export { namespaceSlotAt, namespaceSwitcher, namespaceTarget, type NamespaceSlot, type NamespaceTarget, } from "./namespace.js";
+export { type BatchSeparator, type NamespaceStatementForm, type SqlDialectOptions } from "./tokens.js";
+export { defaultKeyword, defaultValuesInsert, quoteIdentifierWith, sqlSavepoints, sqlLiteral, type IdentifierQuote, type SqlLiteralOptions, } from "./literals.js";
+export { identifierWriter, sqlGenerator, sqlImporter, type GeneratorOptions, type ImporterOptions, } from "./generate.js";
+export { columnChanged, ddlScript, designError, NOTHING_TO_CHANGE, REFERENTIAL_ACTIONS, referencesClause, tableDesignOf, tableDifference, unchanged, validateDesign, type TableDifference, } from "./objects.js";
+export { ALREADY_EXPLAIN, commonExplainRefusal, CREATE_TABLE_AS, EXPLAIN_ONE_STATEMENT, explainedVerb, NOTHING_TO_EXPLAIN, planPropertyValue, planText, sqlExplainable, type ExplainableOptions, } from "./explain.js";
+export { routineSlots, type RoutineSlot, type RoutineSlots } from "./routines.js";

package/dist/sql/index.js

@@ -0,0 +1,16 @@
+export { SQL_KEYWORDS, sqlCompleter } from "./complete.js";
+export { sqlInspector } from "./inspect.js";
+export { FUNCTION_CATEGORIES, functionInfo, functionItem, functionSpecs, isAvailable, parseSignature, signatureLabel, SQL_FUNCTIONS, } from "./functions.js";
+export { callAt } from "./signature.js";
+export { classifyTokens, EXPLAIN_ANALYZE_REASON_PREFIX, transactionEffect, } from "./classify.js";
+export { FORMAT_DIALECTS, sqlFormatter } from "./format.js";
+export { sqlParameters } from "./parameters.js";
+export { sqlSplitter, sqlStatementStream } from "./splitter.js";
+export { parseSimpleSelect, SELECT_READ_ONLY_REASONS } from "./select.js";
+export { namespaceSlotAt, namespaceSwitcher, namespaceTarget, } from "./namespace.js";
+export {} from "./tokens.js";
+export { defaultKeyword, defaultValuesInsert, quoteIdentifierWith, sqlSavepoints, sqlLiteral, } from "./literals.js";
+export { identifierWriter, sqlGenerator, sqlImporter, } from "./generate.js";
+export { columnChanged, ddlScript, designError, NOTHING_TO_CHANGE, REFERENTIAL_ACTIONS, referencesClause, tableDesignOf, tableDifference, unchanged, validateDesign, } from "./objects.js";
+export { ALREADY_EXPLAIN, commonExplainRefusal, CREATE_TABLE_AS, EXPLAIN_ONE_STATEMENT, explainedVerb, NOTHING_TO_EXPLAIN, planPropertyValue, planText, sqlExplainable, } from "./explain.js";
+export { routineSlots } from "./routines.js";

package/dist/sql/inspect.d.ts

@@ -0,0 +1,10 @@
+import type { SqlLanguage } from "@tablecraft-app/plugin-api";
+import { type InspectorOptions } from "./inspectContext.js";
+export type { InspectorOptions } from "./inspectContext.js";
+/**
+ * The shared inspector every built-in plugin spreads into its `SqlLanguage` (plan 108): it reads
+ * each statement with the completer's lexer, scope and catalog lookups and reports what DataGrip's
+ * inspections of the same ids would, with their quick fixes. It never rejects: a statement or an
+ * inspection that throws only reports less.
+ */
+export declare function sqlInspector(options: InspectorOptions): Required<Pick<SqlLanguage, "inspect">>;

package/dist/sql/inspect.js

@@ -0,0 +1,134 @@
+import { StatementView } from "./inspectContext.js";
+import { reservedProblems, resolveProblems } from "./inspectResolve.js";
+import { STYLE_INSPECTIONS } from "./inspectStyle.js";
+import { syntaxProblems, unterminatedProblem } from "./inspectSyntax.js";
+import { namespaceTarget } from "./namespace.js";
+import { nameRules } from "./resolution.js";
+import { sqlSplitter } from "./splitter.js";
+import { Lexer } from "./tokens.js";
+/** DataGrip's suppression comment: `-- noinspection SqlResolve,SqlSyntax` on the line above a statement. */
+const NOINSPECTION = /^(?:--|#)\s*noinspection\s+([\w\s,]+)$/i;
+const ID_SEPARATOR = /[\s,]+/;
+const NEWLINE = "\n";
+const INSPECTIONS = [
+    syntaxProblems,
+    resolveProblems,
+    reservedProblems,
+    ...STYLE_INSPECTIONS,
+];
+function lex(text, options) {
+    const lexer = new Lexer(text, options.dialect);
+    const tokens = [];
+    for (let token = lexer.next(); token !== null; token = lexer.next())
+        tokens.push(token);
+    return tokens;
+}
+function newlines(text) {
+    let count = 0;
+    for (let at = text.indexOf(NEWLINE); at >= 0; at = text.indexOf(NEWLINE, at + 1))
+        count += 1;
+    return count;
+}
+/** The inspections the comments directly above a statement silence; a blank line ends the run. */
+function suppressedBy(text, comments, statementFrom) {
+    const ids = new Set();
+    let reach = statementFrom;
+    for (let at = comments.length - 1; at >= 0; at -= 1) {
+        const comment = comments[at];
+        if (comment === undefined || newlines(text.slice(comment.to, reach)) > 1)
+            break;
+        const match = NOINSPECTION.exec(text.slice(comment.from, comment.to).trim());
+        for (const id of match?.[1]?.split(ID_SEPARATOR) ?? [])
+            if (id !== "")
+                ids.add(id);
+        reach = comment.from;
+    }
+    return ids;
+}
+/**
+ * The shared inspector every built-in plugin spreads into its `SqlLanguage` (plan 108): it reads
+ * each statement with the completer's lexer, scope and catalog lookups and reports what DataGrip's
+ * inspections of the same ids would, with their quick fixes. It never rejects: a statement or an
+ * inspection that throws only reports less.
+ */
+export function sqlInspector(options) {
+    const rules = nameRules(options);
+    const split = sqlSplitter(options.dialect);
+    async function inspectStatement(text, tokens, lookup) {
+        const view = new StatementView(text, tokens, options, rules, lookup);
+        const problems = [];
+        for (const inspection of INSPECTIONS) {
+            try {
+                problems.push(...(await inspection(view)));
+            }
+            catch {
+                continue;
+            }
+        }
+        return problems;
+    }
+    async function follow(span, lookup) {
+        const target = namespaceTarget(span.sql, options.dialect);
+        if (target !== null)
+            await lookup.switchTo(target);
+    }
+    async function inspectAll(request, catalog) {
+        const { text } = request;
+        const disabled = new Set(request.disabled ?? []);
+        const tokens = lex(text, options);
+        const lookup = new rules.Lookup(catalog);
+        const problems = [];
+        const suppressions = [];
+        let cursor = 0;
+        for (const span of split(text)) {
+            const comments = [];
+            while (cursor < tokens.length && (tokens[cursor]?.from ?? 0) < span.from) {
+                const token = tokens[cursor];
+                if (token?.kind === "comment")
+                    comments.push(token);
+                cursor += 1;
+            }
+            const own = [];
+            while (cursor < tokens.length && (tokens[cursor]?.from ?? 0) < span.to) {
+                const token = tokens[cursor];
+                if (token !== undefined && token.kind !== "comment" && token.kind !== "delimiter")
+                    own.push(token);
+                cursor += 1;
+            }
+            const ids = suppressedBy(text, comments, span.from);
+            suppressions.push({ span, ids });
+            try {
+                const found = await inspectStatement(text, own, lookup);
+                problems.push(...found.filter((entry) => !ids.has(entry.inspection)));
+            }
+            catch {
+                // A statement the reader cannot follow reports nothing; the others still do.
+            }
+            try {
+                await follow(span, lookup);
+            }
+            catch {
+                // The namespace stays where it was.
+            }
+        }
+        const unterminated = unterminatedProblem(text, tokens.at(-1), options.dialect);
+        if (unterminated !== null) {
+            const owner = suppressions.find(({ span }) => span.from <= unterminated.from && unterminated.from < span.to);
+            if (owner === undefined || !owner.ids.has(unterminated.inspection))
+                problems.push(unterminated);
+        }
+        return problems
+            .filter((entry) => !disabled.has(entry.inspection))
+            .sort((left, right) => left.from - right.from || left.to - right.to);
+    }
+    return {
+        inspect: async (request, catalog) => {
+            try {
+                return await inspectAll(request, catalog);
+            }
+            catch {
+                return [];
+            }
+        },
+    };
+}