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

package/dist/sql/explain.js

@@ -0,0 +1,108 @@
+import { classifyTokens } from "./classify.js";
+import { sqlSplitter } from "./splitter.js";
+import { significantTokens } from "./tokens.js";
+import { EXPLAIN_VERBS, mainVerb, words } from "./words.js";
+export const NOTHING_TO_EXPLAIN = "There is no statement to explain; put the caret in one.";
+export const EXPLAIN_ONE_STATEMENT = "Explain one statement at a time.";
+export const ALREADY_EXPLAIN = "This statement is already an EXPLAIN; run it with Run to see its rows.";
+const CREATE = "CREATE";
+const TABLE = "TABLE";
+const AS = "AS";
+/** How `ExplainableOptions` names `CREATE TABLE … AS`, which `CREATE TABLE` alone is not. */
+export const CREATE_TABLE_AS = "CREATE TABLE … AS";
+function anyOf(items) {
+    if (items.length <= 1)
+        return items.join("");
+    return `${items.slice(0, -1).join(", ")} or ${items.at(-1) ?? ""}`;
+}
+function isCreateTableAs(list) {
+    if (list[0]?.word !== CREATE)
+        return false;
+    const table = list.findIndex((entry) => entry.depth === 0 && entry.word === TABLE);
+    return table > 0 && list.some((entry, at) => at > table && entry.depth === 0 && entry.word === AS);
+}
+/**
+ * The refusals every dialect shares: nothing to explain, more than one statement, and a statement
+ * that already is an EXPLAIN. Null when none applies.
+ */
+export function commonExplainRefusal(sql, dialect) {
+    const spans = sqlSplitter(dialect)(sql);
+    if (spans.length === 0)
+        return NOTHING_TO_EXPLAIN;
+    if (spans.length > 1)
+        return EXPLAIN_ONE_STATEMENT;
+    const first = words(sql, significantTokens(sql, dialect))[0]?.word;
+    return first !== undefined && EXPLAIN_VERBS.has(first) ? ALREADY_EXPLAIN : null;
+}
+/**
+ * The verb that decides what `sql` does, upper case: `SELECT`, the verb after `WITH …`, or
+ * `CREATE_TABLE_AS`; empty for no statement. A plugin picks its EXPLAIN format by it.
+ */
+export function explainedVerb(sql, dialect) {
+    const list = words(sql, significantTokens(sql, dialect));
+    return isCreateTableAs(list) ? CREATE_TABLE_AS : (list[mainVerb(list)]?.word ?? "");
+}
+/**
+ * `SqlLanguage.explainable` from a dialect's verb lists: the shared refusals, then the statement's
+ * main verb against what the dialect explains and analyses. A statement writes when it is not a read.
+ */
+export function sqlExplainable(options) {
+    const verbs = new Set(options.verbs);
+    const analyzeVerbs = new Set(options.analyzeVerbs);
+    const explainable = (sql, { analyze }) => {
+        const common = commonExplainRefusal(sql, options.dialect);
+        if (common !== null)
+            return { ok: false, reason: common };
+        const statement = sqlSplitter(options.dialect)(sql)[0]?.sql ?? sql;
+        const verb = explainedVerb(statement, options.dialect);
+        if (!verbs.has(verb)) {
+            return {
+                ok: false,
+                reason: `${options.name} cannot explain a ${verb} statement. Explain ${anyOf(options.verbs)} instead.`,
+            };
+        }
+        if (analyze && !analyzeVerbs.has(verb)) {
+            return {
+                ok: false,
+                reason: analyzeVerbs.size === 0
+                    ? `${options.name} cannot run Explain Analyse; use Explain Plan.`
+                    : `${options.name} analyses only ${anyOf(options.analyzeVerbs)} statements; use Explain Plan for this ${verb}.`,
+            };
+        }
+        return { ok: true, writes: classifyTokens(statement, options.dialect).kind !== "read" };
+    };
+    return { explainable };
+}
+const LINE_BREAK = "\n";
+/** The first cell of every row as text, one row per line: what an EXPLAIN printed. */
+export function planText(rows) {
+    return rows
+        .map((row) => {
+        const cell = row[0];
+        if (cell === null || cell === undefined)
+            return "";
+        if (typeof cell === "object")
+            return cell.kind === "json" ? cell.text : JSON.stringify(cell);
+        return String(cell);
+    })
+        .join(LINE_BREAK);
+}
+/**
+ * A plan property's value as one line of text: strings as they are, lists joined with commas,
+ * anything nested as JSON. Null for nothing worth showing: null, or an empty list.
+ */
+export function planPropertyValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return null;
+        const flat = value.every((item) => item === null || typeof item !== "object");
+        return flat ? value.map((item) => String(item)).join(", ") : JSON.stringify(value);
+    }
+    return JSON.stringify(value);
+}

package/dist/sql/format.d.ts

@@ -0,0 +1,26 @@
+import type { ParameterStyle, SqlLanguage } from "@tablecraft-app/plugin-api";
+import { type DialectOptions } from "sql-formatter";
+import { type SqlDialectOptions } from "./tokens.js";
+/** The `sql-formatter` dialects plugins may name (decisions 042 and 100). */
+export declare const FORMAT_DIALECTS: {
+    readonly postgresql: DialectOptions;
+    readonly mysql: DialectOptions;
+    readonly sqlite: DialectOptions;
+    readonly plsql: DialectOptions;
+    readonly transactsql: DialectOptions;
+};
+export type FormatDialect = keyof typeof FORMAT_DIALECTS;
+export interface FormatterOptions {
+    readonly dialect: FormatDialect;
+    /** The same dialect options the splitter gets; `delimiterCommand` makes a `DELIMITER` line refuse. */
+    readonly lexer: SqlDialectOptions;
+    /** The placeholders `SqlLanguage.parameters` reads, so the formatter keeps `:id` and `$1` whole. */
+    readonly parameters: readonly ParameterStyle[];
+}
+/**
+ * `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 declare function sqlFormatter(options: FormatterOptions): Pick<SqlLanguage, "format">;

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">>;