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

package/dist/sql/select.js

@@ -0,0 +1,287 @@
+import { unquote } from "./scope.js";
+import { significantTokens, wordOf } from "./tokens.js";
+/** Why a statement is not a simple SELECT, for the console's toolbar (plan 026). */
+export const SELECT_READ_ONLY_REASONS = {
+    notSelect: "the statement is not a simple SELECT",
+    with: "the statement has a WITH clause",
+    distinct: "the result is DISTINCT",
+    joins: "the result joins two or more tables",
+    aggregates: "the result aggregates rows",
+    windows: "the result uses window functions",
+    combines: "the result combines queries",
+    derived: "the result reads a subquery or function, not a table",
+    noTable: "the result reads no table",
+};
+const SELECT = "SELECT";
+const FROM = "FROM";
+const AS = "AS";
+const STAR = "*";
+const DOT = ".";
+const COMMA = ",";
+const OPEN = "(";
+const CLOSE = ")";
+const OVER = "OVER";
+const ONLY = "ONLY";
+const ON = "ON";
+const NOT = "NOT";
+const WITH = "WITH";
+const DISTINCT = new Set(["DISTINCT", "DISTINCTROW", "UNIQUE"]);
+const SELECT_ALL = "ALL";
+/** What may follow the table at the top level. */
+const TAIL_CLAUSES = new Set(["WHERE", "ORDER", "LIMIT", "OFFSET", "FETCH"]);
+const JOINS = new Set(["JOIN", "INNER", "LEFT", "RIGHT", "FULL", "CROSS", "NATURAL", "STRAIGHT_JOIN", "OUTER"]);
+const GROUPING = new Set(["GROUP", "HAVING"]);
+const SET_OPERATIONS = new Set(["UNION", "INTERSECT", "EXCEPT", "MINUS"]);
+/** Top-level words after the table that make the statement more than a read of its rows. */
+const OTHER_TAIL = new Set([
+    "WINDOW",
+    "INTO",
+    "FOR",
+    "LOCK",
+    "QUALIFY",
+    "TABLESAMPLE",
+    "PARTITION",
+    "USE",
+    "FORCE",
+    "IGNORE",
+    "INDEXED",
+    "NOT",
+]);
+const AGGREGATES = new Set([
+    "COUNT",
+    "SUM",
+    "AVG",
+    "MIN",
+    "MAX",
+    "ARRAY_AGG",
+    "STRING_AGG",
+    "GROUP_CONCAT",
+    "JSON_AGG",
+    "JSONB_AGG",
+    "JSON_OBJECT_AGG",
+    "JSONB_OBJECT_AGG",
+    "JSON_ARRAYAGG",
+    "JSON_OBJECTAGG",
+    "JSON_GROUP_ARRAY",
+    "JSON_GROUP_OBJECT",
+    "BOOL_AND",
+    "BOOL_OR",
+    "EVERY",
+    "BIT_AND",
+    "BIT_OR",
+    "BIT_XOR",
+    "STDDEV",
+    "STDDEV_POP",
+    "STDDEV_SAMP",
+    "VARIANCE",
+    "VAR_POP",
+    "VAR_SAMP",
+    "TOTAL",
+    "XMLAGG",
+    "PERCENTILE_CONT",
+    "PERCENTILE_DISC",
+    "MODE",
+]);
+const NOT_A_NAME = /^[0-9$]/;
+/** The text and kind checks the parser needs over one statement's tokens. */
+class Reader {
+    text;
+    tokens;
+    constructor(text, tokens) {
+        this.text = text;
+        this.tokens = tokens;
+    }
+    word(token) {
+        return token?.kind === "word" ? wordOf(this.text, token) : null;
+    }
+    symbol(token) {
+        return token?.kind === "symbol" ? this.text.slice(token.from, token.to) : null;
+    }
+    identifier(token) {
+        if (token === undefined)
+            return null;
+        const raw = this.text.slice(token.from, token.to);
+        if (token.kind === "quoted")
+            return { name: unquote(raw), quoted: true, from: token.from, to: token.to };
+        if (token.kind === "word" && !NOT_A_NAME.test(raw))
+            return { name: raw, quoted: false, from: token.from, to: token.to };
+        return null;
+    }
+    /** Each token's parenthesis depth, and whether it sits inside a parenthesised subquery. */
+    depths() {
+        const depth = [];
+        const inSubquery = [];
+        const subqueries = [];
+        this.tokens.forEach((token, index) => {
+            const symbol = this.symbol(token);
+            if (symbol === CLOSE)
+                subqueries.pop();
+            depth.push(subqueries.length);
+            inSubquery.push(subqueries.some(Boolean));
+            if (symbol === OPEN)
+                subqueries.push(this.word(this.tokens[index + 1]) === SELECT);
+        });
+        return { depth, inSubquery };
+    }
+}
+/** A dotted name `a.b.c` from `at`: its parts and the index after it, or null when `at` holds no name. */
+function dottedName(reader, at) {
+    const first = reader.identifier(reader.tokens[at]);
+    if (first === null)
+        return null;
+    const parts = [first];
+    let next = at + 1;
+    while (reader.symbol(reader.tokens[next]) === DOT) {
+        const part = reader.identifier(reader.tokens[next + 1]);
+        if (part === null)
+            break;
+        parts.push(part);
+        next += 2;
+    }
+    return { parts, next };
+}
+function selectItem(reader, from, to) {
+    const tokens = reader.tokens;
+    if (to - from === 1 && reader.symbol(tokens[from]) === STAR)
+        return { kind: "star", qualifier: null };
+    const name = dottedName(reader, from);
+    if (name === null)
+        return { kind: "expression" };
+    if (name.next === to - 2 && reader.symbol(tokens[name.next]) === DOT && reader.symbol(tokens[to - 1]) === STAR) {
+        return { kind: "star", qualifier: name.parts.at(-1) ?? null };
+    }
+    const last = name.parts.at(-1);
+    if (last === undefined)
+        return { kind: "expression" };
+    const column = () => ({ kind: "column", qualifier: name.parts.slice(0, -1), name: last });
+    if (name.next === to)
+        return column();
+    const aliasAt = reader.word(tokens[name.next]) === AS ? name.next + 1 : name.next;
+    if (aliasAt === to - 1 && (tokens[aliasAt]?.kind === "string" || reader.identifier(tokens[aliasAt]) !== null)) {
+        return column();
+    }
+    return { kind: "expression" };
+}
+/** Why the select list makes the result something other than the table's rows, or null. */
+function selectListRefusal(reader, from, to, inSubquery) {
+    const tokens = reader.tokens;
+    let aggregate = false;
+    for (let at = from; at < to; at += 1) {
+        if (inSubquery[at] === true)
+            continue;
+        const word = reader.word(tokens[at]);
+        if (word === OVER)
+            return SELECT_READ_ONLY_REASONS.windows;
+        if (word !== null && AGGREGATES.has(word) && reader.symbol(tokens[at + 1]) === OPEN)
+            aggregate = true;
+    }
+    return aggregate ? SELECT_READ_ONLY_REASONS.aggregates : null;
+}
+/** Why the words after the table refuse editing, or null when they only filter, order and limit. */
+function tailRefusal(reader, from, depth) {
+    const tokens = reader.tokens;
+    const first = reader.word(tokens[from]);
+    if (from < tokens.length && (first === null || !TAIL_CLAUSES.has(first))) {
+        if (reader.symbol(tokens[from]) === COMMA || (first !== null && JOINS.has(first))) {
+            return SELECT_READ_ONLY_REASONS.joins;
+        }
+        if (first !== null && GROUPING.has(first))
+            return SELECT_READ_ONLY_REASONS.aggregates;
+        if (first !== null && SET_OPERATIONS.has(first))
+            return SELECT_READ_ONLY_REASONS.combines;
+        return SELECT_READ_ONLY_REASONS.notSelect;
+    }
+    for (let at = from; at < tokens.length; at += 1) {
+        if (depth[at] !== 0)
+            continue;
+        const word = reader.word(tokens[at]);
+        if (word === null)
+            continue;
+        if (GROUPING.has(word))
+            return SELECT_READ_ONLY_REASONS.aggregates;
+        if (SET_OPERATIONS.has(word))
+            return SELECT_READ_ONLY_REASONS.combines;
+        if (JOINS.has(word) || (word === ON && at > from))
+            return SELECT_READ_ONLY_REASONS.joins;
+        if (OTHER_TAIL.has(word) && word !== NOT)
+            return SELECT_READ_ONLY_REASONS.notSelect;
+    }
+    return null;
+}
+/**
+ * `sql`, one statement, read as a single-table SELECT (plan 026). Strict on purpose: whatever
+ * it does not recognise is read-only, because a wrong "editable" writes to the wrong rows.
+ */
+export function parseSimpleSelect(sql, dialect) {
+    const tokens = significantTokens(sql, dialect).filter((token) => token.kind !== "delimiter");
+    const reader = new Reader(sql, tokens);
+    const head = reader.word(tokens[0]);
+    if (head === WITH)
+        return { readOnly: SELECT_READ_ONLY_REASONS.with };
+    if (reader.symbol(tokens[0]) === OPEN)
+        return { readOnly: SELECT_READ_ONLY_REASONS.combines };
+    if (head !== SELECT)
+        return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
+    const { depth, inSubquery } = reader.depths();
+    let at = 1;
+    const modifier = reader.word(tokens[at]);
+    if (modifier !== null && DISTINCT.has(modifier))
+        return { readOnly: SELECT_READ_ONLY_REASONS.distinct };
+    if (modifier === SELECT_ALL)
+        at += 1;
+    const fromAt = tokens.findIndex((token, index) => index >= at && depth[index] === 0 && reader.word(token) === FROM);
+    if (fromAt < 0)
+        return { readOnly: SELECT_READ_ONLY_REASONS.noTable };
+    const refusal = selectListRefusal(reader, at, fromAt, inSubquery);
+    if (refusal !== null)
+        return { readOnly: refusal };
+    const items = [];
+    let itemFrom = at;
+    for (let index = at; index <= fromAt; index += 1) {
+        if (index === fromAt || (depth[index] === 0 && reader.symbol(tokens[index]) === COMMA)) {
+            if (index === itemFrom)
+                return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
+            items.push(selectItem(reader, itemFrom, index));
+            itemFrom = index + 1;
+        }
+    }
+    if (reader.symbol(tokens[fromAt + 1]) === OPEN)
+        return { readOnly: SELECT_READ_ONLY_REASONS.derived };
+    if (reader.word(tokens[fromAt + 1]) === ONLY)
+        return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
+    const table = dottedName(reader, fromAt + 1);
+    if (table === null)
+        return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
+    if (reader.symbol(tokens[table.next]) === OPEN)
+        return { readOnly: SELECT_READ_ONLY_REASONS.derived };
+    let next = table.next;
+    let alias = null;
+    const afterTable = reader.word(tokens[next]);
+    if (afterTable === AS) {
+        alias = reader.identifier(tokens[next + 1]);
+        if (alias === null)
+            return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
+        next += 2;
+    }
+    else if (tokens[next] !== undefined && (afterTable === null || !isClauseWord(afterTable))) {
+        alias = reader.identifier(tokens[next]);
+        if (alias !== null)
+            next += 1;
+    }
+    const tail = tailRefusal(reader, next, depth);
+    if (tail !== null)
+        return { readOnly: tail };
+    const name = table.parts.at(-1);
+    if (name === undefined)
+        return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
+    return { qualifier: table.parts.slice(0, -1), name, alias, items };
+}
+function isClauseWord(word) {
+    return (TAIL_CLAUSES.has(word) ||
+        JOINS.has(word) ||
+        GROUPING.has(word) ||
+        SET_OPERATIONS.has(word) ||
+        OTHER_TAIL.has(word) ||
+        word === ON ||
+        word === ONLY);
+}

package/dist/sql/signature.d.ts

@@ -0,0 +1,18 @@
+import type { SqlDialectOptions } from "./tokens.js";
+/** The function call around a caret, before the plugin looks its name up. */
+export interface CallAt {
+    /** As written. */
+    readonly name: string;
+    readonly argument: number;
+    readonly from: number;
+    readonly to: number;
+}
+/**
+ * Finds the innermost call around `offset` whose name `known` accepts, counting its top-level
+ * commas; strings, comments and quoted names are tokens of their own, so their commas never count.
+ * Grouping parentheses are looked through; a subquery, a non-function name before `(` or a caret
+ * in a string or comment ends the search with null. `reserved` holds the dialect's keywords: a
+ * function spelled like one (`VALUES`, `LEFT`) is a call only where an operand fits, not after a
+ * name such as `INSERT INTO t VALUES (`.
+ */
+export declare function callAt(text: string, offset: number, dialect: SqlDialectOptions, reserved: ReadonlySet<string>, known: (name: string) => boolean): CallAt | null;

package/dist/sql/signature.js

@@ -0,0 +1,137 @@
+import { statementTokens } from "./scope.js";
+/** Words a relation or routine name follows, so `TABLE upper (` defines rather than calls. */
+const NAME_INTRODUCERS = new Set([
+    "CALL",
+    "EXISTS",
+    "FROM",
+    "FUNCTION",
+    "INDEX",
+    "INTO",
+    "JOIN",
+    "KEY",
+    "PROCEDURE",
+    "REFERENCES",
+    "TABLE",
+    "TRIGGER",
+    "UPDATE",
+    "VIEW",
+]);
+const QUERY_STARTS = new Set(["SELECT", "WITH"]);
+function symbol(text, token, char) {
+    return token?.kind === "symbol" && text.slice(token.from, token.to) === char;
+}
+function upperWord(text, token) {
+    return token?.kind === "word" ? text.slice(token.from, token.to).toUpperCase() : null;
+}
+/**
+ * Finds the innermost call around `offset` whose name `known` accepts, counting its top-level
+ * commas; strings, comments and quoted names are tokens of their own, so their commas never count.
+ * Grouping parentheses are looked through; a subquery, a non-function name before `(` or a caret
+ * in a string or comment ends the search with null. `reserved` holds the dialect's keywords: a
+ * function spelled like one (`VALUES`, `LEFT`) is a call only where an operand fits, not after a
+ * name such as `INSERT INTO t VALUES (`.
+ */
+export function callAt(text, offset, dialect, reserved, known) {
+    const { tokens, literal } = statementTokens(text, offset, dialect);
+    if (literal)
+        return null;
+    function callable(at) {
+        const name = tokens[at];
+        const word = upperWord(text, name);
+        if (name === undefined || word === null || !known(word))
+            return null;
+        const before = tokens[at - 1];
+        if (symbol(text, before, "."))
+            return null;
+        const previous = upperWord(text, before);
+        if (previous !== null && NAME_INTRODUCERS.has(previous))
+            return null;
+        if (!reserved.has(word))
+            return name;
+        const operandFits = before === undefined ||
+            (before.kind === "symbol" && !symbol(text, before, ")")) ||
+            (previous !== null && reserved.has(previous));
+        return operandFits ? name : null;
+    }
+    const frames = [];
+    let index = 0;
+    for (; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (token === undefined || token.from >= offset)
+            break;
+        if (symbol(text, token, "(")) {
+            const name = callable(index - 1);
+            frames.push({ name, named: name === null && !grouping(text, tokens[index - 1]), open: index, commas: 0 });
+        }
+        else if (symbol(text, token, ")"))
+            frames.pop();
+        else if (symbol(text, token, ",")) {
+            const top = frames.at(-1);
+            if (top !== undefined)
+                top.commas += 1;
+        }
+    }
+    for (let depth = frames.length - 1; depth >= 0; depth -= 1) {
+        const frame = frames[depth];
+        if (frame === undefined)
+            return null;
+        if (frame.name === null) {
+            if (frame.named || QUERY_STARTS.has(upperWord(text, tokens[frame.open + 1]) ?? ""))
+                return null;
+            continue;
+        }
+        return {
+            name: text.slice(frame.name.from, frame.name.to),
+            argument: frame.commas,
+            from: frame.name.from,
+            to: closeOf(text, tokens, index, frames.length - depth) ?? offset,
+        };
+    }
+    return null;
+}
+/** Whether a `(` after `before` only groups: it starts the statement or follows an operator or operand keyword. */
+function grouping(text, before) {
+    if (before === undefined)
+        return true;
+    if (before.kind === "symbol")
+        return !symbol(text, before, ")");
+    return GROUPING_WORDS.has(upperWord(text, before) ?? "");
+}
+/** Keywords an operand follows, so a `(` right after one groups an expression instead of naming a list. */
+const GROUPING_WORDS = new Set([
+    "AND",
+    "AS",
+    "BETWEEN",
+    "BY",
+    "CASE",
+    "DISTINCT",
+    "ELSE",
+    "HAVING",
+    "IS",
+    "LIKE",
+    "NOT",
+    "ON",
+    "OR",
+    "RETURN",
+    "SELECT",
+    "SET",
+    "THEN",
+    "WHEN",
+    "WHERE",
+    "XOR",
+]);
+/** The end of the `)` closing the call `levels` parentheses up from the caret, if the statement has one. */
+function closeOf(text, tokens, from, levels) {
+    let open = levels;
+    for (let at = from; at < tokens.length; at += 1) {
+        const token = tokens[at];
+        if (symbol(text, token, "("))
+            open += 1;
+        else if (symbol(text, token, ")")) {
+            open -= 1;
+            if (open === 0)
+                return token?.to ?? null;
+        }
+    }
+    return null;
+}

package/dist/sql/splitter.d.ts

@@ -0,0 +1,15 @@
+import type { StatementSpan, StatementStream } from "@tablecraft-app/plugin-api";
+import { type SqlDialectOptions } from "./tokens.js";
+/**
+ * A configurable splitter plugins may build `SqlLanguage.split` on (decision 023). It tokenizes
+ * strings, quoted identifiers, comments, dollar quotes, `DELIMITER` lines and `BEGIN … END`
+ * bodies, and drops statements that hold nothing but comments.
+ */
+export declare function sqlSplitter(options?: SqlDialectOptions): (text: string) => StatementSpan[];
+/**
+ * `sqlSplitter` over text that arrives in pieces, for `SqlLanguage.splitStream` (decision 081).
+ * Only whole lines are scanned before `end`, so a token, a `DELIMITER` line or a multi-character
+ * delimiter cut by a push is read once its line is complete. Statements come out exactly as
+ * `sqlSplitter` would find them in the concatenated text.
+ */
+export declare function sqlStatementStream(options?: SqlDialectOptions): () => StatementStream;

package/dist/sql/splitter.js

@@ -0,0 +1,217 @@
+import { DEFAULT_DELIMITER, Lexer, separatorLineAt, wordOf, } from "./tokens.js";
+const DELIMITER_COMMAND = "DELIMITER";
+/** A body only opens inside a statement that defines a routine, so a column called `begin` stays a column. */
+const BODY_OWNERS = new Set(["TRIGGER", "FUNCTION", "PROCEDURE", "EVENT"]);
+const CREATE = "CREATE";
+const CASE = "CASE";
+const END = "END";
+/** `END IF`, `END LOOP` and the like close a construct the splitter never counted as opened. */
+const UNCOUNTED_END_TARGETS = new Set(["IF", "LOOP", "WHILE", "REPEAT"]);
+/** Words that may stand between `CREATE` and the kind of routine: `CREATE OR REPLACE EDITIONABLE PROCEDURE`. */
+const ROUTINE_HEAD_WORDS = new Set(["OR", "REPLACE", "ALTER", "EDITIONABLE", "NONEDITIONABLE"]);
+const ALTER = "ALTER";
+/** What `sqlcmd` and SQL*Plus send whole up to the separator line, `;` included. */
+const SEPARATED_ROUTINES = {
+    go: new Set(["PROCEDURE", "PROC", "FUNCTION", "TRIGGER"]),
+    slash: new Set(["PROCEDURE", "FUNCTION", "TRIGGER", "PACKAGE", "TYPE"]),
+};
+/** An Oracle anonymous block, which also runs to the `/` line. */
+const ANONYMOUS_BLOCK_STARTS = new Set(["DECLARE", "BEGIN"]);
+const LINE_BREAK = /\r?\n/;
+const NEWLINE = "\n";
+/**
+ * A stream rescans its unfinished text only once it has doubled, so one statement spanning a
+ * thousand pushes is read a logarithmic number of times rather than once per push.
+ */
+const RESCAN_GROWTH = 2;
+function freshStatement(from) {
+    return {
+        from,
+        to: from,
+        words: 0,
+        isCreate: false,
+        definesRoutine: false,
+        depth: 0,
+        pendingEnd: false,
+        routineHead: false,
+        toSeparator: false,
+    };
+}
+function scanner(options) {
+    const blockKeywords = new Set((options.blockKeywords ?? []).map((keyword) => keyword.toUpperCase()));
+    const separator = options.batchSeparator;
+    return (text, startDelimiter, final) => {
+        const spans = [];
+        const lexer = new Lexer(text, options);
+        let delimiter = startDelimiter;
+        let statement = null;
+        let checkpoint = { offset: 0, delimiter };
+        const flush = (end, repeat) => {
+            if (statement !== null) {
+                const span = { from: statement.from, to: statement.to, sql: text.slice(statement.from, statement.to) };
+                spans.push(repeat === undefined ? span : { ...span, repeat });
+            }
+            statement = null;
+            checkpoint = { offset: end, delimiter };
+        };
+        const readDelimiterCommand = (token) => {
+            const rest = text.slice(token.to);
+            const line = rest.split(LINE_BREAK, 1)[0] ?? "";
+            const value = line.trim().split(/\s+/, 1)[0] ?? "";
+            if (value !== "")
+                delimiter = value;
+            lexer.position = token.to + line.length;
+            checkpoint = { offset: lexer.position, delimiter };
+        };
+        const resolvePendingEnd = (current, token) => {
+            if (!current.pendingEnd)
+                return false;
+            current.pendingEnd = false;
+            const word = token.kind === "word" ? wordOf(text, token) : "";
+            if (UNCOUNTED_END_TARGETS.has(word))
+                return true;
+            current.depth = Math.max(0, current.depth - 1);
+            return word === CASE;
+        };
+        for (let token = lexer.next(delimiter); token !== null; token = lexer.next(delimiter)) {
+            if (token.kind === "comment")
+                continue;
+            const line = separator === undefined ? null : separatorLineAt(text, token, separator);
+            if (line !== null) {
+                flush(line.to, line.repeat);
+                lexer.position = line.to;
+                continue;
+            }
+            if (token.kind === "delimiter") {
+                const current = statement;
+                if (current !== null)
+                    resolvePendingEnd(current, token);
+                const insideBody = current !== null && (current.toSeparator || (current.depth > 0 && delimiter === DEFAULT_DELIMITER));
+                if (insideBody)
+                    current.to = token.to;
+                else
+                    flush(token.to);
+                continue;
+            }
+            if (statement === null) {
+                if (options.delimiterCommand === true && token.kind === "word" && wordOf(text, token) === DELIMITER_COMMAND) {
+                    readDelimiterCommand(token);
+                    continue;
+                }
+                statement = freshStatement(token.from);
+            }
+            const current = statement;
+            current.to = token.to;
+            const consumed = resolvePendingEnd(current, token);
+            if (token.kind !== "word" || consumed)
+                continue;
+            const word = wordOf(text, token);
+            current.words += 1;
+            if (current.words === 1) {
+                current.isCreate = word === CREATE;
+                current.routineHead = current.isCreate || (separator === "go" && word === ALTER);
+                current.toSeparator = separator === "slash" && ANONYMOUS_BLOCK_STARTS.has(word);
+                continue;
+            }
+            if (current.routineHead && separator !== undefined) {
+                current.routineHead = ROUTINE_HEAD_WORDS.has(word);
+                if (SEPARATED_ROUTINES[separator].has(word))
+                    current.toSeparator = true;
+            }
+            if (current.depth > 0) {
+                if (word === END)
+                    current.pendingEnd = true;
+                else if (blockKeywords.has(word) || word === CASE)
+                    current.depth += 1;
+            }
+            else if (current.definesRoutine && blockKeywords.has(word)) {
+                current.depth = 1;
+            }
+            else if (current.isCreate && BODY_OWNERS.has(word)) {
+                current.definesRoutine = true;
+            }
+        }
+        if (final)
+            flush(text.length);
+        return { spans, checkpoint };
+    };
+}
+/**
+ * A configurable splitter plugins may build `SqlLanguage.split` on (decision 023). It tokenizes
+ * strings, quoted identifiers, comments, dollar quotes, `DELIMITER` lines and `BEGIN … END`
+ * bodies, and drops statements that hold nothing but comments.
+ */
+export function sqlSplitter(options = {}) {
+    const scan = scanner(options);
+    return (text) => scan(text, DEFAULT_DELIMITER, true).spans;
+}
+/**
+ * `sqlSplitter` over text that arrives in pieces, for `SqlLanguage.splitStream` (decision 081).
+ * Only whole lines are scanned before `end`, so a token, a `DELIMITER` line or a multi-character
+ * delimiter cut by a push is read once its line is complete. Statements come out exactly as
+ * `sqlSplitter` would find them in the concatenated text.
+ */
+export function sqlStatementStream(options = {}) {
+    const scan = scanner(options);
+    return () => {
+        let pending = "";
+        /** Where `pending` starts in everything pushed, and the line and column there. */
+        let base = 0;
+        let line = 1;
+        let column = 1;
+        let delimiter = DEFAULT_DELIMITER;
+        let scannedLength = 0;
+        const advance = (consumed) => {
+            let lineStart = -1;
+            for (let at = consumed.indexOf(NEWLINE); at >= 0; at = consumed.indexOf(NEWLINE, at + 1)) {
+                line += 1;
+                lineStart = at + 1;
+            }
+            column = lineStart < 0 ? column + consumed.length : consumed.length - lineStart + 1;
+            base += consumed.length;
+        };
+        const located = (spans) => {
+            const startLine = line;
+            const startColumn = column;
+            let cursor = 0;
+            let cursorLine = startLine;
+            let cursorColumn = startColumn;
+            return spans.map((span) => {
+                for (let at = pending.indexOf(NEWLINE, cursor); at >= 0 && at < span.from; at = pending.indexOf(NEWLINE, at + 1)) {
+                    cursorLine += 1;
+                    cursorColumn = 1;
+                    cursor = at + 1;
+                }
+                cursorColumn += span.from - cursor;
+                cursor = span.from;
+                return { ...span, from: base + span.from, to: base + span.to, line: cursorLine, column: cursorColumn };
+            });
+        };
+        const run = (final) => {
+            const scanned = final ? pending : pending.slice(0, pending.lastIndexOf(NEWLINE) + 1);
+            if (scanned === "")
+                return [];
+            const { spans, checkpoint } = scan(scanned, delimiter, final);
+            const statements = located(spans);
+            const consumed = final ? pending.length : checkpoint.offset;
+            advance(pending.slice(0, consumed));
+            pending = pending.slice(consumed);
+            delimiter = checkpoint.delimiter;
+            scannedLength = pending.length;
+            return statements;
+        };
+        return {
+            push: (text) => {
+                pending += text;
+                if (pending.length < scannedLength * RESCAN_GROWTH)
+                    return [];
+                return run(false);
+            },
+            end: () => {
+                const statements = run(true);
+                pending = "";
+                return statements;
+            },
+        };
+    };
+}

package/dist/sql/suggest.d.ts

@@ -0,0 +1,6 @@
+/** How many "Did you mean" fixes an unresolved name offers. */
+export declare const MAX_SUGGESTIONS = 3;
+/** The edit distance between two names, compared case-blind. */
+export declare function editDistance(left: string, right: string): number;
+/** The closest `candidates` to `name`, nearest first, within max(2, a third of its length). */
+export declare function suggestions(name: string, candidates: Iterable<string>): string[];