@tablecraft-app/plugin-api 1.3.0 → 1.5.0

package/dist/completion.d.ts

@@ -22,6 +22,8 @@ export interface FunctionParameter {
     readonly optional?: boolean;
     /** Repeats: the call may pass it any number of times. */
     readonly variadic?: boolean;
+    /** The keyword written before it instead of a comma, such as `FROM` in `EXTRACT(unit FROM date)`; `|` separates alternatives. */
+    readonly lead?: string;
 }
 /** One way to call a function: its parameters in order and what it returns. */
 export interface FunctionSignature {
@@ -33,7 +35,10 @@ export interface SignatureHelp {
     readonly name: string;
     readonly summary: string;
     readonly signatures: readonly FunctionSignature[];
-    /** The zero-based argument the caret is in: the top-level commas before it inside the call. */
+    /**
+     * The zero-based parameter the caret is in: the top-level commas before it inside the call, or,
+     * when the signature has keyword-led parameters (`lead`), the one the separators walk to.
+     */
     readonly argument: number;
     /** The call's name to the end of its arguments, or to the caret while it is still open. */
     readonly from: number;

package/dist/manifest.d.ts

@@ -74,6 +74,7 @@ export declare const connectionUrlSchema: z.ZodObject<{
         values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strict>>>;
     sets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+    semicolonParams: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export type ConnectionUrl = z.infer<typeof connectionUrlSchema>;
 /**
@@ -181,6 +182,7 @@ export declare const pluginManifestSchema: z.ZodObject<{
                 values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strict>>>;
             sets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+            semicolonParams: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>;
         network: z.ZodOptional<z.ZodObject<{
             host: z.ZodString;

package/dist/manifest.js

@@ -68,6 +68,11 @@ export const connectionUrlSchema = z.strictObject({
     sets: z
         .record(z.string().regex(URL_SCHEME), z.record(z.string().regex(FIELD_KEY), z.union([z.string(), z.number(), z.boolean()])))
         .optional(),
+    /**
+     * The JDBC SQL Server form, `scheme://host[\instance][:port][;name=value…]` (plan 055): parameters
+     * follow `;`, a `{…}` value may hold one, and `\instance` is the parameter `instanceName`.
+     */
+    semicolonParams: z.boolean().optional(),
 });
 /**
  * Which fields hold the server's address (decision 070), so the host can open an SSH tunnel and

package/dist/plugin.d.ts

@@ -122,6 +122,12 @@ export interface ExecuteOptions {
      * leads each row with a `node` column, and anything else is a `ServerNode.id`.
      */
     readonly node?: string;
+    /**
+     * `StatementSpan.repeat` of the statement, at least 2, when the script asks for it to run more
+     * than once (SQL Server's `GO 3`, decision 100). A plugin that splits such scripts runs it that
+     * many times and answers with the last run; any other plugin never receives it.
+     */
+    readonly repeat?: number;
 }
 /** `ExecuteOptions.node`: the plugin routes the command by its keys (decision 114). */
 export declare const NODE_AUTO = "auto";
@@ -311,7 +317,8 @@ export interface StatementSpan {
     readonly sql: string;
     /**
      * How many times the script asks for the statement to run: SQL Server's `GO 3` after it
-     * (decision 100). Absent means once. The host never repeats a statement; a plugin may.
+     * (decision 100). Absent means once. The host never repeats a statement; it passes the count
+     * as `ExecuteOptions.repeat` and the plugin runs it that many times.
      */
     readonly repeat?: number;
 }

package/dist/sql/complete.js

@@ -1,4 +1,4 @@
-import { functionItem, functionName, isAvailable } from "./functions.js";
+import { functionItem, functionName, functionPackage, isAvailable, leadMatches, memberItem, } from "./functions.js";
 import { callAt } from "./signature.js";
 import { parseSimpleSelect, SELECT_READ_ONLY_REASONS } from "./select.js";
 import { scopeAt } from "./scope.js";
@@ -70,18 +70,65 @@ const BOOST = {
     keyword: -10,
 };
 const UNQUOTED_WORD = "^[A-Za-z0-9_$]*$";
+/** Where `@` and `#` start a name (`variables`), the typed `@@` stays part of what is filtered. */
+const VARIABLE_WORD = "^[@#]*[A-Za-z0-9_$]*$";
 const ALIAS_WORD_BREAK = /[^A-Za-z0-9]+|(?<=[a-z0-9])(?=[A-Z])/;
 const FALLBACK_ALIAS = "t";
 const QUOTES = new Set(['"', "`", "["]);
 /** Below every other namespace: `USE mysql` is legitimate but rarely meant. */
 const SYSTEM_NAMESPACE_BOOST = -20;
 const CURRENT_DETAIL = "current";
+const COMMA = ",";
+const MEMBER_SEPARATOR = ".";
+/**
+ * Walks `separators` through `signature`: a comma moves to the next parameter without a lead, a
+ * word to the next one it leads. A word nothing leads is an argument's own (`YEAR`, `DECIMAL`).
+ * Past the last parameter a comma keeps counting, as the hint's variadic rule expects; a variadic
+ * parameter keyword-led ones follow (`CHAR(code... USING charset)`) takes every comma.
+ */
+function argumentAt(signature, separators) {
+    const { parameters } = signature;
+    let at = 0;
+    let entered = false;
+    let led = 0;
+    for (const separator of separators) {
+        if (separator === COMMA) {
+            const next = parameters.findIndex((parameter, index) => index > at && parameter.lead === undefined);
+            if (next >= 0)
+                at = next;
+            else if (!(parameters[at]?.variadic === true && at < parameters.length - 1))
+                at += 1;
+            entered = true;
+            continue;
+        }
+        const next = parameters.findIndex((parameter, index) => (index > at || (index === at && !entered)) &&
+            parameter.lead !== undefined &&
+            leadMatches(parameter.lead, separator));
+        if (next < 0)
+            continue;
+        at = next;
+        entered = true;
+        led += 1;
+    }
+    return { argument: at, led };
+}
+/** The argument the caret is in, by the overload whose leads the call follows most; the first on a tie. */
+function argumentOf(spec, call) {
+    let best = null;
+    for (const signature of spec.signatures) {
+        const found = argumentAt(signature, call.separators ?? []);
+        if (best === null || found.led > best.led)
+            best = found;
+    }
+    return best?.argument ?? call.argument;
+}
 function relationKind(relation) {
     return relation.kind === "table" ? "table" : "view";
 }
 /** The shared completion and navigation every built-in plugin spreads into its `SqlLanguage` (decision 028). */
 export function sqlCompleter(options) {
     const reserved = new Set(options.keywords.map((keyword) => keyword.toUpperCase()));
+    const unquotedWord = options.dialect.variables === true ? VARIABLE_WORD : UNQUOTED_WORD;
     const { denotes, sameIdentifier, cteNamed, sourceNamed, serverOf, Lookup } = nameRules(options);
     const specs = new Map();
     for (const spec of options.functions) {
@@ -93,6 +140,13 @@ export function sqlCompleter(options) {
     function specNamed(name, server) {
         return specs.get(name.toUpperCase())?.find((spec) => isAvailable(spec, server));
     }
+    /** The members of the package `qualifier` names, as offered after its dot. */
+    function memberItems(qualifier, server) {
+        const name = qualifier.map((part) => part.name.toUpperCase()).join(MEMBER_SEPARATOR);
+        return availableFunctions(server, true)
+            .filter((spec) => typeof spec !== "string" && functionPackage(spec) === name)
+            .map((spec) => memberItem(spec, BOOST.function));
+    }
     function quoted(name) {
         return options.plainIdentifier.test(name) && !reserved.has(name.toUpperCase())
             ? name
@@ -115,10 +169,13 @@ export function sqlCompleter(options) {
             .filter((keyword) => !except.has(keyword.toUpperCase()))
             .map((keyword) => item("keyword", keyword, keyword, null));
     }
-    function availableFunctions(server) {
+    /** Plain functions, or with `members` the package members only: a bare name never offers `pkg.member`. */
+    function availableFunctions(server, members = false) {
         const offered = new Set();
         return options.functions.filter((spec) => {
             const name = functionName(spec).toUpperCase();
+            if ((functionPackage(spec) !== null) !== members)
+                return false;
             if (offered.has(name) || (typeof spec !== "string" && !isAvailable(spec, server)))
                 return false;
             offered.add(name);
@@ -131,21 +188,22 @@ export function sqlCompleter(options) {
         if (last === undefined)
             return [];
         const relational = clause === "relation" || clause === "join";
+        const members = relational ? [] : memberItems(qualifier, lookup.server);
         if (qualifier.length === 1 && !relational) {
             const source = sourceNamed(query, last);
             if (source !== undefined)
-                return columnItems(await lookup.columnsOf(source, query));
+                return [...columnItems(await lookup.columnsOf(source, query)), ...members];
             const cte = cteNamed(query, last);
             if (cte !== undefined)
-                return columnItems(await lookup.cteColumns(cte, 1));
+                return [...columnItems(await lookup.cteColumns(cte, 1)), ...members];
         }
         const namespace = await lookup.namespace(qualifier);
         if (namespace !== undefined)
-            return relationItems(await lookup.relations(namespace.path), null);
+            return [...members, ...relationItems(await lookup.relations(namespace.path), null)];
         if (relational)
             return [];
         const found = await lookup.relation(qualifier.slice(0, -1), last);
-        return found === null ? [] : columnItems(found.relation.columns);
+        return found === null ? members : [...columnItems(found.relation.columns), ...members];
     }
     async function relationContextItems(scope, lookup) {
         const current = lookup.current;
@@ -169,7 +227,9 @@ export function sqlCompleter(options) {
             .filter((word) => word !== "")
             .map((word) => word.charAt(0).toLowerCase())
             .join("");
-        const base = initials === "" || !options.plainIdentifier.test(initials) ? FALLBACK_ALIAS : initials;
+        // Unquoted, an alias folds like any name; `c` is written as is and reads back as `C` under upper folding.
+        const folded = options.identifierFolding === "upper" ? initials.toUpperCase() : initials;
+        const base = initials === "" || !options.plainIdentifier.test(folded) ? FALLBACK_ALIAS : initials;
         let alias = base;
         for (let suffix = 1; taken.has(alias) || reserved.has(alias.toUpperCase()); suffix += 1)
             alias = `${base}${String(suffix)}`;
@@ -203,7 +263,9 @@ export function sqlCompleter(options) {
                 continue;
             const near = source.alias === null
                 ? relationReference(found.path, found.relation.name, lookup.current)
-                : quoted(source.alias.name);
+                : source.alias.quoted
+                    ? options.quoteIdentifier(source.alias.name)
+                    : source.alias.name;
             for (const key of found.relation.foreignKeys) {
                 const alias = aliasFor(key.target.relation, new Set(taken));
                 const on = key.columns
@@ -321,7 +383,7 @@ export function sqlCompleter(options) {
                 const lookup = new Lookup(catalog);
                 await lookup.follow(request.text, request.offset);
                 const items = await namespaceItems(slot, lookup);
-                return { from: slot.from, to: slot.to, items, validFor: slot.quote === null ? UNQUOTED_WORD : null };
+                return { from: slot.from, to: slot.to, items, validFor: slot.quote === null ? unquotedWord : null };
             }
         }
         const { text, offset, shift } = wrap(request);
@@ -335,7 +397,7 @@ export function sqlCompleter(options) {
             from: scope.prefixFrom - shift,
             to: offset - shift,
             items: typedQuote ? quotedLabels(items) : items,
-            validFor: typedQuote ? null : UNQUOTED_WORD,
+            validFor: typedQuote ? null : unquotedWord,
         };
     }
     function sourceDeclaring(query, word) {
@@ -463,7 +525,11 @@ export function sqlCompleter(options) {
     function signatureAt(request, catalog) {
         const { text, offset, shift } = wrap(request);
         const server = serverOf(catalog);
-        const call = callAt(text, offset, options.dialect, reserved, (name) => specNamed(name, server) !== undefined);
+        const callable = (name) => {
+            const spec = specNamed(name, server);
+            return spec !== undefined && spec.bare !== true;
+        };
+        const call = callAt(text, offset, options.dialect, reserved, callable);
         const spec = call === null ? undefined : specNamed(call.name, server);
         if (call === null || spec === undefined)
             return Promise.resolve(null);
@@ -471,7 +537,7 @@ export function sqlCompleter(options) {
             name: spec.name.toLowerCase(),
             summary: spec.summary,
             signatures: spec.signatures,
-            argument: call.argument,
+            argument: argumentOf(spec, call),
             from: call.from - shift,
             to: call.to - shift,
         });

package/dist/sql/functions.d.ts

@@ -21,26 +21,42 @@ export interface FunctionSpec {
     readonly summary: string;
     readonly category: FunctionCategory;
     readonly available?: ServerRange;
+    /** Written without parentheses, such as Oracle's `SYSDATE`; the call is the name alone and has no hint. */
+    readonly bare?: true;
 }
-/** `[name, signatures, summary, available?]`, a signature written `"date, format -> string"`. */
+/**
+ * `[name, signatures, summary, available?]`, a signature written `"date, format -> string"`, a
+ * keyword-led parameter `"unit FROM date -> integer"`, a bare function `"= date"` and a procedure
+ * `"str ->"`. A name `PKG.MEMBER` is offered after `pkg.`.
+ */
 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. */
+/** Whether `lead` is `word` or offers it among its `|` alternatives. */
+export declare function leadMatches(lead: string, word: string): boolean;
+/**
+ * Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats, an
+ * upper-case word between names the keyword before the next (`"unit FROM date -> integer"`).
+ * `"= date"` is a bare function's and `"str ->"` a procedure's, which returns nothing.
+ */
 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. */
+/** `(date, format) → string`, the popup's detail for one signature; a lead replaces the comma, a procedure has no `→`. */
 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. */
+/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments, the name alone when bare. */
 export declare function functionItem(spec: FunctionSpec | string, boost: number): CompletionItem;
+/** The package a spec named `PKG.MEMBER` belongs to, upper case; null for a plain function. */
+export declare function functionPackage(spec: FunctionSpec | string): string | null;
+/** A package member as offered after `pkg.`: the member's name alone, the info naming it in full. */
+export declare function memberItem(spec: FunctionSpec, 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. */

package/dist/sql/functions.js

@@ -20,7 +20,13 @@ const SHOWN_ARROW = "→";
 const OPTIONAL_MARK = "?";
 const VARIADIC_MARK = "...";
 const COMPARATOR = /^(>=|<=|>|<|=)?(\d+(?:\.\d+)*)$/;
-function parameter(written) {
+const BARE_MARK = "=";
+const LEAD_WORD = /^[A-Z][A-Z_]*$/;
+const LEAD_CHOICE = "|";
+const PARAMETER_SEPARATOR = ",";
+const COMMA_SHOWN = ", ";
+const MEMBER_SEPARATOR = ".";
+function parameter(written, lead) {
     let name = written.trim();
     const variadic = name.endsWith(VARIADIC_MARK);
     if (variadic)
@@ -28,28 +34,85 @@ function parameter(written) {
     const optional = name.endsWith(OPTIONAL_MARK);
     if (optional)
         name = name.slice(0, -OPTIONAL_MARK.length).trim();
-    return { name, ...(optional ? { optional } : {}), ...(variadic ? { variadic } : {}) };
+    return {
+        name,
+        ...(optional ? { optional } : {}),
+        ...(variadic ? { variadic } : {}),
+        ...(lead === null ? {} : { lead }),
+    };
 }
-/** Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats. */
+function isLeadWord(word) {
+    return word.split(LEAD_CHOICE).every((choice) => LEAD_WORD.test(choice));
+}
+/** Whether `lead` is `word` or offers it among its `|` alternatives. */
+export function leadMatches(lead, word) {
+    return lead.split(LEAD_CHOICE).includes(word);
+}
+/**
+ * One comma-separated part: an upper-case word between names leads the next, as one before the
+ * first parameter does; one standing alone is a keyword choice. After a comma the keyword is the
+ * argument's own (`date, INTERVAL expr unit`), since the comma already separates it.
+ */
+function leadParameters(part, index) {
+    const words = part.trim().split(/\s+/);
+    const parameters = [];
+    let lead = null;
+    let name = [];
+    const flush = () => {
+        if (name.length > 0)
+            parameters.push(parameter(name.join(" "), lead));
+        name = [];
+        lead = null;
+    };
+    words.forEach((word, at) => {
+        const next = words[at + 1];
+        const afterComma = at === 0 && index > 0;
+        if (!afterComma && isLeadWord(word) && next !== undefined && !isLeadWord(next)) {
+            flush();
+            lead = word;
+        }
+        else
+            name.push(word);
+    });
+    flush();
+    return parameters;
+}
+function isBareSignature(written) {
+    return written.trim().startsWith(BARE_MARK);
+}
+/**
+ * Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats, an
+ * upper-case word between names the keyword before the next (`"unit FROM date -> integer"`).
+ * `"= date"` is a bare function's and `"str ->"` a procedure's, which returns nothing.
+ */
 export function parseSignature(written) {
+    if (isBareSignature(written))
+        return { parameters: [], returns: written.trim().slice(BARE_MARK.length).trim() };
     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),
+        parameters: list === "" ? [] : list.split(PARAMETER_SEPARATOR).flatMap(leadParameters),
         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 }),
-    }));
+    return entries.map(([name, signatures, summary, available]) => {
+        const written = typeof signatures === "string" ? [signatures] : signatures;
+        const bare = written.filter(isBareSignature).length;
+        if (bare > 0 && bare < written.length)
+            throw new Error(`${name} mixes "${BARE_MARK} type" with called signatures; write the bare form as "-> type".`);
+        return {
+            name,
+            signatures: written.map(parseSignature),
+            summary,
+            category,
+            ...(available === undefined ? {} : { available }),
+            ...(bare > 0 ? { bare: true } : {}),
+        };
+    });
 }
 function compareVersions(left, right) {
     for (let at = 0; at < Math.max(left.length, right.length); at += 1) {
@@ -91,37 +154,65 @@ export function isAvailable(spec, server) {
         .filter((comparator) => comparator !== "")
         .every((comparator) => satisfies(server.version, comparator));
 }
-function shownParameter(parameter) {
+function shownParameter(parameter, index) {
     const name = parameter.variadic === true ? `${parameter.name}${VARIADIC_MARK}` : parameter.name;
-    return parameter.optional === true ? `[${name}]` : name;
+    const led = parameter.lead === undefined ? name : `${parameter.lead} ${name}`;
+    const separator = index === 0 ? "" : parameter.lead === undefined ? COMMA_SHOWN : " ";
+    return separator + (parameter.optional === true ? `[${led}]` : led);
 }
-/** `(date, format) → string`, the popup's detail for one signature. */
+function returnsLabel(returns) {
+    return returns === "" ? "" : `${SHOWN_ARROW} ${returns}`;
+}
+/** `(date, format) → string`, the popup's detail for one signature; a lead replaces the comma, a procedure has no `→`. */
 export function signatureLabel(signature) {
-    return `(${signature.parameters.map(shownParameter).join(", ")}) ${SHOWN_ARROW} ${signature.returns}`;
+    const list = `(${signature.parameters.map(shownParameter).join("")})`;
+    const returns = returnsLabel(signature.returns);
+    return returns === "" ? list : `${list} ${returns}`;
+}
+function shownSignature(spec, signature) {
+    return spec.bare === true ? returnsLabel(signature.returns) : signatureLabel(signature);
 }
 /** 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)}`);
+    const gap = spec.bare === true ? " " : "";
+    const lines = spec.signatures.map((signature) => `${label}${gap}${shownSignature(spec, 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();
+/**
+ * A spec as an item: `name()` with the caret between the parentheses when it takes arguments, or
+ * the name alone for a bare one. `label` is what the popup offers, the member alone after `pkg.`.
+ */
+function specItem(spec, label, boost) {
     const first = spec.signatures[0];
     const takesArguments = spec.signatures.some((signature) => signature.parameters.length > 0);
+    const bare = spec.bare === true;
     return {
         label,
         kind: "function",
-        detail: first === undefined ? null : signatureLabel(first),
-        apply: `${label}()`,
+        detail: first === undefined ? null : shownSignature(spec, first),
+        apply: bare ? label : `${label}()`,
         boost,
         info: functionInfo(spec),
-        caret: takesArguments ? label.length + 1 : null,
+        caret: takesArguments && !bare ? label.length + 1 : null,
     };
 }
+/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments, the name alone when bare. */
+export function functionItem(spec, boost) {
+    if (typeof spec === "string")
+        return { label: spec, kind: "function", detail: null, apply: spec, boost, info: null, caret: null };
+    return specItem(spec, spec.name.toLowerCase(), boost);
+}
+/** The package a spec named `PKG.MEMBER` belongs to, upper case; null for a plain function. */
+export function functionPackage(spec) {
+    const name = functionName(spec);
+    const dot = name.lastIndexOf(MEMBER_SEPARATOR);
+    return dot < 0 ? null : name.slice(0, dot).toUpperCase();
+}
+/** A package member as offered after `pkg.`: the member's name alone, the info naming it in full. */
+export function memberItem(spec, boost) {
+    return specItem(spec, spec.name.slice(spec.name.lastIndexOf(MEMBER_SEPARATOR) + 1).toLowerCase(), boost);
+}
 /** The name a function entry is offered under, either form. */
 export function functionName(spec) {
     return typeof spec === "string" ? spec : spec.name;

package/dist/sql/inspectResolve.js

@@ -28,6 +28,7 @@ const COLUMN_CLAUSES = new Set([
 /** Symbols right before a word that make it a parameter or variable: `:name`, `@var`, `x::type`. */
 const PARAMETER_MARKS = new Set([":", "@", "?"]);
 const PARAMETER_START = /^[$@:]/;
+const PARAMETER_OR_TEMPORARY = /^[@#]/;
 /** Rows a statement may name without declaring them: PostgreSQL's `EXCLUDED`, a trigger's `NEW` and `OLD`. */
 const PSEUDO_RELATIONS = new Set(["EXCLUDED", "NEW", "OLD"]);
 const RELATION_INTRODUCERS = new Set(["FROM", "JOIN", "UPDATE", "INTO", "STRAIGHT_JOIN"]);
@@ -146,6 +147,9 @@ async function unresolvedRelation(view, query, source) {
         return [];
     if (!source.name.quoted && NOT_RELATION_NAMES.has(source.name.name.toUpperCase()))
         return [];
+    // SQL Server's `#temp` and `@table` live in no catalog the explorer reads.
+    if (!source.name.quoted && PARAMETER_OR_TEMPORARY.test(source.name.name))
+        return [];
     const { lookup } = view;
     let path = lookup.current;
     if (source.qualifier.length > 0) {

package/dist/sql/namespace.d.ts

@@ -23,7 +23,8 @@ export interface NamespaceSlot {
 }
 /**
  * Where the caret at `offset` names a namespace a session-namespace statement of the dialect moves
- * to: `USE |` or the elements of `SET search_path TO a, |` and `SET SCHEMA |`. Null anywhere else,
+ * to: `USE |`, `ALTER SESSION SET CURRENT_SCHEMA = |` or the elements of `SET search_path TO a, |`
+ * and `SET SCHEMA |`. Null anywhere else,
  * and after a name whose closing quote is typed.
  */
 export declare function namespaceSlotAt(text: string, offset: number, dialect: SqlDialectOptions): NamespaceSlot | null;

package/dist/sql/namespace.js

@@ -82,6 +82,17 @@ function searchPathTarget(text, tokens) {
         return null;
     return { kind: "schema", candidates: names };
 }
+const ALTER_SESSION_PREFIX = ["ALTER", "SESSION", "SET", "CURRENT_SCHEMA", "="];
+function alterSessionPrefix(text, tokens) {
+    return ALTER_SESSION_PREFIX.every((word, at) => wordAt(text, tokens, at) === word);
+}
+function alterSessionTarget(text, tokens) {
+    if (tokens.length !== ALTER_SESSION_PREFIX.length + 1 || !alterSessionPrefix(text, tokens))
+        return null;
+    const token = tokens[ALTER_SESSION_PREFIX.length];
+    const name = identifier(text, token);
+    return name === null || token?.kind === "string" ? null : { kind: "schema", candidates: [name] };
+}
 const NAME_TOKENS = new Set(["word", "quoted", "string"]);
 /** The statement's tokens around `offset`, comments dropped; null when the caret is in a comment. */
 function tokensAround(text, offset, dialect) {
@@ -136,7 +147,8 @@ function searchPathListStart(text, tokens) {
 }
 /**
  * Where the caret at `offset` names a namespace a session-namespace statement of the dialect moves
- * to: `USE |` or the elements of `SET search_path TO a, |` and `SET SCHEMA |`. Null anywhere else,
+ * to: `USE |`, `ALTER SESSION SET CURRENT_SCHEMA = |` or the elements of `SET search_path TO a, |`
+ * and `SET SCHEMA |`. Null anywhere else,
  * and after a name whose closing quote is typed.
  */
 export function namespaceSlotAt(text, offset, dialect) {
@@ -168,6 +180,13 @@ export function namespaceSlotAt(text, offset, dialect) {
                 continue;
             return { kind: "database", from, to: offset, quote, listed: [] };
         }
+        if (form === "alterSessionSchema") {
+            if (prefix?.kind === "string" || before.length !== ALTER_SESSION_PREFIX.length)
+                continue;
+            if (!alterSessionPrefix(text, before))
+                continue;
+            return { kind: "schema", from, to: offset, quote, listed: [] };
+        }
         const start = searchPathListStart(text, before);
         if (start === null)
             continue;
@@ -190,15 +209,26 @@ export function namespaceTarget(sql, dialect) {
         return null;
     const tokens = significantTokens(sql, dialect).filter((token) => token.kind !== "delimiter");
     for (const form of forms) {
-        const target = form === "use" ? useTarget(sql, tokens) : searchPathTarget(sql, tokens);
+        const target = TARGET_READERS[form](sql, tokens);
         if (target !== null)
             return target;
     }
     return null;
 }
+const TARGET_READERS = {
+    use: useTarget,
+    searchPath: searchPathTarget,
+    alterSessionSchema: alterSessionTarget,
+};
 const SWITCH_TARGETS = {
     use: "topLevel",
     searchPath: "schema",
+    alterSessionSchema: "schema",
+};
+const SWITCH_STATEMENTS = {
+    use: (quoted) => `USE ${quoted}`,
+    searchPath: (quoted) => `SET search_path TO ${quoted}`,
+    alterSessionSchema: (quoted) => `ALTER SESSION SET CURRENT_SCHEMA = ${quoted}`,
 };
 /**
  * The console's namespace switch for a dialect moving its namespace by `form` (decision 060):
@@ -214,7 +244,7 @@ export function namespaceSwitcher(form, quoteIdentifier) {
             if (name === undefined) {
                 throw new PluginError("statementFailed", "A namespace switch names no namespace; pick one from the list.");
             }
-            return form === "use" ? `USE ${quoteIdentifier(name)}` : `SET search_path TO ${quoteIdentifier(name)}`;
+            return SWITCH_STATEMENTS[form](quoteIdentifier(name));
         },
     };
 }

package/dist/sql/signature.d.ts

@@ -3,13 +3,21 @@ import type { SqlDialectOptions } from "./tokens.js";
 export interface CallAt {
     /** As written. */
     readonly name: string;
+    /** The top-level commas before the caret. */
     readonly argument: number;
+    /**
+     * The call's top-level `,` and words before the caret, in order, words upper case: what moves a
+     * keyword-led parameter list such as `EXTRACT(YEAR FROM d)` along. Always set by `callAt`;
+     * optional so a value built against the older shape still type-checks (decision 106).
+     */
+    readonly separators?: readonly string[];
     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.
+ * commas and listing its separators; strings, comments and quoted names are tokens of their own,
+ * so their commas never count. `pkg.member (` asks `known` for `PKG.MEMBER`.
  * 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

package/dist/sql/signature.js

@@ -1,4 +1,8 @@
 import { statementTokens } from "./scope.js";
+const COMMA = ",";
+const MEMBER_SEPARATOR = ".";
+/** Calls a procedure by name, so it may come before a package member as it never may before a function. */
+const CALL_WORD = "CALL";
 /** Words a relation or routine name follows, so `TABLE upper (` defines rather than calls. */
 const NAME_INTRODUCERS = new Set([
     "CALL",
@@ -25,7 +29,8 @@ function upperWord(text, token) {
 }
 /**
  * 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.
+ * commas and listing its separators; strings, comments and quoted names are tokens of their own,
+ * so their commas never count. `pkg.member (` asks `known` for `PKG.MEMBER`.
  * 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
@@ -35,23 +40,42 @@ export function callAt(text, offset, dialect, reserved, known) {
     const { tokens, literal } = statementTokens(text, offset, dialect);
     if (literal)
         return null;
-    function callable(at) {
+    /** `pkg.member` ending at `at`, when the package's spec knows the member. */
+    function member(at) {
         const name = tokens[at];
+        const owner = tokens[at - 2];
         const word = upperWord(text, name);
-        if (name === undefined || word === null || !known(word))
+        const ownerWord = upperWord(text, owner);
+        if (name === undefined || owner === undefined || word === null || ownerWord === null)
+            return null;
+        if (!known(`${ownerWord}${MEMBER_SEPARATOR}${word}`))
             return null;
+        const previous = upperWord(text, tokens[at - 3]);
+        if (previous !== null && previous !== CALL_WORD && NAME_INTRODUCERS.has(previous))
+            return null;
+        return {
+            written: `${text.slice(owner.from, owner.to)}${MEMBER_SEPARATOR}${text.slice(name.from, name.to)}`,
+            from: owner.from,
+        };
+    }
+    function callable(at) {
+        const name = tokens[at];
         const before = tokens[at - 1];
-        if (symbol(text, before, "."))
+        if (symbol(text, before, MEMBER_SEPARATOR))
+            return member(at);
+        const word = upperWord(text, name);
+        if (name === undefined || word === null || !known(word))
             return null;
+        const found = { written: text.slice(name.from, name.to), from: name.from };
         const previous = upperWord(text, before);
         if (previous !== null && NAME_INTRODUCERS.has(previous))
             return null;
         if (!reserved.has(word))
-            return name;
+            return found;
         const operandFits = before === undefined ||
             (before.kind === "symbol" && !symbol(text, before, ")")) ||
             (previous !== null && reserved.has(previous));
-        return operandFits ? name : null;
+        return operandFits ? found : null;
     }
     const frames = [];
     let index = 0;
@@ -61,14 +85,27 @@ export function callAt(text, offset, dialect, reserved, known) {
             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 });
+            frames.push({
+                name,
+                named: name === null && !grouping(text, tokens[index - 1]),
+                open: index,
+                commas: 0,
+                separators: [],
+            });
         }
         else if (symbol(text, token, ")"))
             frames.pop();
-        else if (symbol(text, token, ",")) {
+        else if (symbol(text, token, COMMA)) {
             const top = frames.at(-1);
-            if (top !== undefined)
+            if (top !== undefined) {
                 top.commas += 1;
+                top.separators.push(COMMA);
+            }
+        }
+        else {
+            const word = upperWord(text, token);
+            if (word !== null)
+                frames.at(-1)?.separators.push(word);
         }
     }
     for (let depth = frames.length - 1; depth >= 0; depth -= 1) {
@@ -81,8 +118,9 @@ export function callAt(text, offset, dialect, reserved, known) {
             continue;
         }
         return {
-            name: text.slice(frame.name.from, frame.name.to),
+            name: frame.name.written,
             argument: frame.commas,
+            separators: frame.separators,
             from: frame.name.from,
             to: closeOf(text, tokens, index, frames.length - depth) ?? offset,
         };

package/dist/sql/tokens.d.ts

@@ -26,13 +26,16 @@ export interface SqlDialectOptions {
     readonly qQuotes?: boolean;
     /** `N'…'` national character strings. */
     readonly nationalStrings?: boolean;
+    /** SQL Server `@local`, `@@global` and `#temp` names: `@` and `#` are part of a word. */
+    readonly variables?: boolean;
 }
 export type BatchSeparator = "go" | "slash";
 /**
  * `use` is MySQL's `USE db`; `searchPath` is PostgreSQL's `SET [SESSION | LOCAL] search_path`,
- * `SET SCHEMA` and `RESET search_path` / `RESET ALL`.
+ * `SET SCHEMA` and `RESET search_path` / `RESET ALL`; `alterSessionSchema` is Oracle's
+ * `ALTER SESSION SET CURRENT_SCHEMA = name`.
  */
-export type NamespaceStatementForm = "use" | "searchPath";
+export type NamespaceStatementForm = "use" | "searchPath" | "alterSessionSchema";
 export type TokenKind = "word" | "quoted" | "string" | "comment" | "symbol" | "delimiter";
 export interface Token {
     readonly kind: TokenKind;

package/dist/sql/tokens.js

@@ -16,6 +16,7 @@ const Q_QUOTE_PAIRS = new Map([
 const STRING_QUOTE = "'";
 const BRACKET_OPEN = "[";
 const BRACKET_CLOSE = "]";
+const VARIABLE_CHARS = new Set(["@", "#"]);
 function isSpace(char) {
     return char === " " || char === "\t" || char === "\n" || char === "\r" || char === "\f" || char === "\v";
 }
@@ -70,13 +71,16 @@ export class Lexer {
         else if (char === "$" && this.options.dollarQuotes === true && this.#dollarTag(at) !== null) {
             token = this.#dollarQuoted(at, this.#dollarTag(at) ?? "");
         }
-        else if (isWordChar(char))
+        else if (this.#isWordChar(char))
             token = this.#word(at, delimiter);
         else
             token = { kind: "symbol", from: at, to: at + 1 };
         this.position = token.to;
         return token;
     }
+    #isWordChar(char) {
+        return isWordChar(char) || (this.options.variables === true && VARIABLE_CHARS.has(char));
+    }
     #lineComment(from) {
         const end = this.text.indexOf(NEWLINE, from);
         return { kind: "comment", from, to: end < 0 ? this.text.length : end };
@@ -160,7 +164,7 @@ export class Lexer {
         const text = this.text;
         const customDelimiter = delimiter !== DEFAULT_DELIMITER;
         let at = from;
-        while (at < text.length && isWordChar(text.charAt(at))) {
+        while (at < text.length && this.#isWordChar(text.charAt(at))) {
             if (customDelimiter && at > from && text.startsWith(delimiter, at))
                 break;
             at += 1;

package/dist/testing/index.d.ts

@@ -87,6 +87,16 @@ export interface ContractFixture {
             readonly config: unknown;
             readonly note: RegExp;
         };
+        /**
+         * False where the dialect cannot interrupt another session's statement and keep it connected,
+         * as SQL Server's `KILL` cannot: every row's `cancel` is null and `cancelSession` rejects.
+         */
+        readonly cancels?: boolean;
+        /**
+         * A session id no session has, for servers that hand a closed session's id to the next login
+         * (SQL Server): without it the test closes a session of its own and waits for its id to go.
+         */
+        readonly missingId?: string;
     };
     /** Required when the plugin declares `routineCall`, which also needs `catalog`. */
     readonly routines?: {
@@ -108,6 +118,8 @@ export interface ContractFixture {
      * default. `LINE_ITEMS_TABLE` is quoted in every dialect and never folded.
      */
     readonly foldName?: (name: string) => string;
+    /** The database stores an empty string as NULL, as Oracle does, so an empty text reads back null. */
+    readonly emptyTextIsNull?: boolean;
 }
 /** Dialect-specific text the suite runs; every member is optional (decision 100). */
 export interface ContractSql {
@@ -128,6 +140,10 @@ export interface ContractSql {
     };
     /** Opens a transaction explicitly in auto-commit mode. */
     readonly begin?: string;
+    /** A name only quoting makes legal, which the dialect accepts; Oracle refuses a `"` inside one. */
+    readonly awkwardIdentifier?: string;
+    /** What `ExplainedPlan.statement` starts with; `EXPLAIN` by default, `SET SHOWPLAN_XML ON` on SQL Server. */
+    readonly explainStatement?: RegExp;
 }
 /** A command and the result tab it opens: column names and rows as wire values. */
 export interface CommandRows {

package/dist/testing/index.js

@@ -117,8 +117,11 @@ export function contractSql(fixture) {
         temporaryTable: fixture.sql?.temporaryTable ??
             ((name, columns) => ({ create: `CREATE TEMPORARY TABLE ${name} (${columns})`, name })),
         begin: fixture.sql?.begin ?? "BEGIN",
+        awkwardIdentifier: fixture.sql?.awkwardIdentifier ?? AWKWARD_IDENTIFIER,
+        explainStatement: fixture.sql?.explainStatement ?? DEFAULT_EXPLAIN_STATEMENT,
     };
 }
+const DEFAULT_EXPLAIN_STATEMENT = /^EXPLAIN\b/i;
 const ROWS_READ_BEFORE_RETURN = 3;
 /** Longer than `BYTES_PREVIEW_LENGTH` and within every fixture's `payload` column (MySQL's is `VARBINARY(64)`). */
 const LONG_BYTES_LENGTH = 48;
@@ -678,9 +681,9 @@ export function runPluginContract(plugin, fixture) {
             });
             it("givenAwkwardIdentifier_whenQuotedAndSelected_thenNameReadsBack", async () => {
                 await withSession(plugin, fixture, async (session) => {
-                    const result = await session.execute(dialectSql.select(`1 AS ${language().quoteIdentifier(AWKWARD_IDENTIFIER)}`));
+                    const result = await session.execute(dialectSql.select(`1 AS ${language().quoteIdentifier(dialectSql.awkwardIdentifier)}`));
                     await collect(result.rows);
-                    expect(result.columns.map((column) => column.name)).toEqual([AWKWARD_IDENTIFIER]);
+                    expect(result.columns.map((column) => column.name)).toEqual([dialectSql.awkwardIdentifier]);
                 });
             });
             it("givenTypeProbeRow_whenSqlInsertPerDialect_thenRoundTripsEqual", async () => {
@@ -861,7 +864,7 @@ export function runPluginContract(plugin, fixture) {
                     const texts = AWKWARD_TEXTS;
                     const rows = texts.map((text, index) => target.columns.map((column) => column.name === fold("id") ? String(index + 1) : column.name === fold("unicode_text") ? text : null));
                     await insertRowsOf(session)(target, rows);
-                    expect(await run(session, `SELECT unicode_text FROM ${TYPE_PROBE_COPY_TABLE} ORDER BY id`)).toEqual(texts.map((text) => [text]));
+                    expect(await run(session, `SELECT unicode_text FROM ${TYPE_PROBE_COPY_TABLE} ORDER BY id`)).toEqual(texts.map((text) => [text === "" && fixture.emptyTextIsNull === true ? null : text]));
                 });
             });
             it("givenCreateTable_whenEveryImportType_thenTableTakesSampleText", async () => {
@@ -904,7 +907,7 @@ export function runPluginContract(plugin, fixture) {
                 return session.introspector;
             }
             async function relationOf(session, name) {
-                return (await introspectorOf(session).describe(path())).relations.find((relation) => relation.name === name);
+                return (await introspectorOf(session).describe(path())).relations.find((relation) => relation.name === fold(name));
             }
             /** Runs a script as the engine does: prepare, the statements in one transaction where it says so, verify, finish. */
             async function apply(session, script) {
@@ -948,14 +951,14 @@ export function runPluginContract(plugin, fixture) {
                 return editorOf().script(change, context);
             }
             function column(name, type, nullable = true) {
-                return { name, type, nullable, default: null, autoIncrement: false, comment: null, original: null };
+                return { name: fold(name), type, nullable, default: null, autoIncrement: false, comment: null, original: null };
             }
             function parentDesign() {
                 return {
-                    name: OBJECT_PARENT_TABLE,
+                    name: fold(OBJECT_PARENT_TABLE),
                     comment: null,
                     columns: [column("id", OBJECT_KEY_TYPE, false)],
-                    primaryKey: ["id"],
+                    primaryKey: [fold("id")],
                     primaryKeyName: null,
                     indexes: [],
                     foreignKeys: [],
@@ -964,7 +967,7 @@ export function runPluginContract(plugin, fixture) {
             }
             function childDesign() {
                 return {
-                    name: OBJECT_CHILD_TABLE,
+                    name: fold(OBJECT_CHILD_TABLE),
                     comment: null,
                     columns: [
                         column("id", OBJECT_KEY_TYPE, false),
@@ -972,14 +975,14 @@ export function runPluginContract(plugin, fixture) {
                         column("label", OBJECT_NARROW_TYPE),
                         column("obsolete", OBJECT_NARROW_TYPE),
                     ],
-                    primaryKey: ["id"],
+                    primaryKey: [fold("id")],
                     primaryKeyName: null,
-                    indexes: [{ name: OBJECT_INDEX, columns: ["label"], unique: false, original: null }],
+                    indexes: [{ name: fold(OBJECT_INDEX), columns: [fold("label")], unique: false, original: null }],
                     foreignKeys: [
                         {
-                            name: OBJECT_FOREIGN_KEY,
-                            columns: ["parent_id"],
-                            target: { path: path(), relation: OBJECT_PARENT_TABLE, columns: ["id"] },
+                            name: fold(OBJECT_FOREIGN_KEY),
+                            columns: [fold("parent_id")],
+                            target: { path: path(), relation: fold(OBJECT_PARENT_TABLE), columns: [fold("id")] },
                             onDelete: "CASCADE",
                             onUpdate: null,
                             original: null,
@@ -1020,8 +1023,8 @@ export function runPluginContract(plugin, fixture) {
                     ...described,
                     columns: [
                         ...described.columns
-                            .filter((entry) => entry.name !== "obsolete")
-                            .map((entry) => (entry.name === "label" ? { ...entry, type: OBJECT_WIDE_TYPE } : entry)),
+                            .filter((entry) => entry.name !== fold("obsolete"))
+                            .map((entry) => (entry.name === fold("label") ? { ...entry, type: OBJECT_WIDE_TYPE } : entry)),
                         column("note", OBJECT_NARROW_TYPE),
                     ],
                     ...extra,
@@ -1030,11 +1033,11 @@ export function runPluginContract(plugin, fixture) {
             it("givenObjectsDeclared_whenCreateTableWithKeyIndexAndForeignKey_thenDescribedAsDesigned", async () => {
                 await withTables(async (session) => {
                     const child = await relationOf(session, OBJECT_CHILD_TABLE);
-                    expect(child?.columns.map((entry) => entry.name)).toEqual(["id", "parent_id", "label", "obsolete"]);
-                    expect(child?.primaryKey?.columns).toEqual(["id"]);
-                    expect(child?.indexes.map((index) => index.name)).toContain(OBJECT_INDEX);
+                    expect(child?.columns.map((entry) => entry.name)).toEqual(["id", "parent_id", "label", "obsolete"].map(fold));
+                    expect(child?.primaryKey?.columns).toEqual([fold("id")]);
+                    expect(child?.indexes.map((index) => index.name)).toContain(fold(OBJECT_INDEX));
                     expect(child?.foreignKeys.map((key) => [key.target.relation, key.target.columns, key.onDelete])).toEqual([
-                        [OBJECT_PARENT_TABLE, ["id"], "CASCADE"],
+                        [fold(OBJECT_PARENT_TABLE), [fold("id")], "CASCADE"],
                     ]);
                 });
             });
@@ -1046,7 +1049,7 @@ export function runPluginContract(plugin, fixture) {
                     const script = await scriptOf(session, {
                         kind: "alterTable",
                         path: path(),
-                        relation: OBJECT_CHILD_TABLE,
+                        relation: fold(OBJECT_CHILD_TABLE),
                         design: editorOf().design(relation),
                     });
                     expect(script.statements).toEqual([]);
@@ -1055,37 +1058,38 @@ export function runPluginContract(plugin, fixture) {
             it("givenTable_whenColumnAddedTypeChangedAndDropped_thenDescribedAfterAndRowsKept", async () => {
                 await withTables(async (session) => {
                     const design = await widenedChild(session);
-                    await apply(session, await scriptOf(session, { kind: "alterTable", path: path(), relation: OBJECT_CHILD_TABLE, design }));
+                    await apply(session, await scriptOf(session, { kind: "alterTable", path: path(), relation: fold(OBJECT_CHILD_TABLE), design }));
                     const child = await relationOf(session, OBJECT_CHILD_TABLE);
-                    expect(child?.columns.map((entry) => entry.name)).toEqual(["id", "parent_id", "label", "note"]);
-                    expect(child?.columns.find((entry) => entry.name === "label")?.type).toMatch(OBJECT_WIDE_LENGTH);
+                    expect(child?.columns.map((entry) => entry.name)).toEqual(["id", "parent_id", "label", "note"].map(fold));
+                    expect(child?.columns.find((entry) => entry.name === fold("label"))?.type).toMatch(OBJECT_WIDE_LENGTH);
                     expect(child?.foreignKeys).toHaveLength(1);
-                    expect(child?.indexes.map((index) => index.name)).toContain(OBJECT_INDEX);
+                    expect(child?.indexes.map((index) => index.name)).toContain(fold(OBJECT_INDEX));
                     expect(await run(session, `SELECT label FROM ${OBJECT_CHILD_TABLE}`)).toEqual([["kept"]]);
                 });
             });
             it.runIf(plugin.capabilities.includes("transactions"))("givenTransactionalScript_whenStatementFails_thenNothingApplied", async () => {
                 await withTables(async (session) => {
-                    // An index named like a table clashes in every dialect whose index names share the table namespace.
+                    // A second index under the table's own index name clashes in every dialect; one named like a
+                    // table does not where index names are per table, as on SQL Server.
                     const design = await widenedChild(session, {});
                     const clashing = {
                         ...design,
                         indexes: [
                             ...design.indexes,
-                            { name: OBJECT_PARENT_TABLE, columns: ["note"], unique: false, original: null },
+                            { name: fold(OBJECT_INDEX), columns: [fold("note")], unique: false, original: null },
                         ],
                     };
                     const script = await scriptOf(session, {
                         kind: "alterTable",
                         path: path(),
-                        relation: OBJECT_CHILD_TABLE,
+                        relation: fold(OBJECT_CHILD_TABLE),
                         design: clashing,
                     });
                     if (!script.transactional)
                         return;
                     await expect(apply(session, script)).rejects.toThrow();
                     const child = await relationOf(session, OBJECT_CHILD_TABLE);
-                    expect(child?.columns.map((entry) => entry.name)).toEqual(["id", "parent_id", "label", "obsolete"]);
+                    expect(child?.columns.map((entry) => entry.name)).toEqual(["id", "parent_id", "label", "obsolete"].map(fold));
                     expect(await run(session, `SELECT label FROM ${OBJECT_CHILD_TABLE}`)).toEqual([["kept"]]);
                 });
             });
@@ -1094,8 +1098,8 @@ export function runPluginContract(plugin, fixture) {
                     await apply(session, await scriptOf(session, {
                         kind: "rename",
                         path: path(),
-                        object: { kind: "table", name: OBJECT_CHILD_TABLE },
-                        name: OBJECT_RENAMED_TABLE,
+                        object: { kind: "table", name: fold(OBJECT_CHILD_TABLE) },
+                        name: fold(OBJECT_RENAMED_TABLE),
                     }));
                     expect(await relationOf(session, OBJECT_CHILD_TABLE)).toBeUndefined();
                     expect((await relationOf(session, OBJECT_RENAMED_TABLE))?.columns).toHaveLength(4);
@@ -1103,7 +1107,12 @@ export function runPluginContract(plugin, fixture) {
             });
             it("givenTableWithRows_whenTruncated_thenEmptyAndStillDescribed", async () => {
                 await withTables(async (session) => {
-                    await apply(session, await scriptOf(session, { kind: "truncate", path: path(), relation: OBJECT_CHILD_TABLE, cascade: false }));
+                    await apply(session, await scriptOf(session, {
+                        kind: "truncate",
+                        path: path(),
+                        relation: fold(OBJECT_CHILD_TABLE),
+                        cascade: false,
+                    }));
                     expect(await run(session, `SELECT id FROM ${OBJECT_CHILD_TABLE}`)).toEqual([]);
                     expect(await relationOf(session, OBJECT_CHILD_TABLE)).toBeDefined();
                 });
@@ -1113,7 +1122,7 @@ export function runPluginContract(plugin, fixture) {
                     await apply(session, await scriptOf(session, {
                         kind: "drop",
                         path: path(),
-                        object: { kind: "table", name: OBJECT_CHILD_TABLE },
+                        object: { kind: "table", name: fold(OBJECT_CHILD_TABLE) },
                         cascade: false,
                     }));
                     expect(await relationOf(session, OBJECT_CHILD_TABLE)).toBeUndefined();
@@ -1405,7 +1414,10 @@ export function runPluginContract(plugin, fixture) {
                 await withCompletion(async (language, catalog) => {
                     const result = await language.complete(at("SELECT * FROM orders o JOIN |", "|"), catalog);
                     const first = [...result.items].sort((left, right) => right.boost - left.boost)[0];
-                    expect(first).toMatchObject({ kind: "join", apply: "customers c ON c.id = o.customer_id" });
+                    expect(first).toMatchObject({
+                        kind: "join",
+                        apply: `${fold("customers")} c ON c.${fold("id")} = o.${fold("customer_id")}`,
+                    });
                 });
             });
             it("givenNameNeedingQuotes_whenCompleting_thenApplyIsQuotedByDialect", async () => {
@@ -1498,7 +1510,7 @@ export function runPluginContract(plugin, fixture) {
                     const read = session.introspector?.definition?.bind(session.introspector);
                     if (read === undefined)
                         throw new Error("A ddl session needs introspector.definition.");
-                    definition = await read(path, name);
+                    definition = await read(path, fold(name));
                 });
                 return definition;
             }
@@ -1634,7 +1646,7 @@ export function runPluginContract(plugin, fixture) {
                 await withSession(plugin, fixture, async (session) => {
                     const plan = await explained(session, dialectSql.explainJoin, false);
                     expect(plan.analyzed).toBe(false);
-                    expect(plan.statement).toMatch(/^EXPLAIN\b/i);
+                    expect(plan.statement).toMatch(dialectSql.explainStatement);
                     expect(plan.statement).toContain(dialectSql.explainJoin);
                     expect(plan.raw).toMatch(/\S/);
                     const nodes = planNodes(plan.roots);
@@ -1787,10 +1799,14 @@ export function runPluginContract(plugin, fixture) {
                 const { path } = namespaceSwitch();
                 const written = switcher();
                 await withSession(plugin, fixture, async (session) => {
+                    // A database switch reaches [database, default schema] on SQL Server, so the target may be a prefix.
                     const listed = (await session.introspector?.namespaces()) ?? [];
-                    const target = listed.find((namespace) => namespace.path.join(".") === path.join("."));
-                    expect(target === undefined ? false : switchableTo(written.targets, target)).toBe(true);
-                    const sql = written.statement(path);
+                    const target = listed
+                        .filter((namespace) => namespace.path.every((part, index) => part === path[index]))
+                        .filter((namespace) => switchableTo(written.targets, namespace))
+                        .sort((a, b) => b.path.length - a.path.length)[0];
+                    expect(target).toBeDefined();
+                    const sql = written.statement(target?.path ?? path);
                     expect(plugin.language?.classify(sql).setsNamespace).toBe(true);
                     await collect((await session.execute(sql)).rows);
                     expect(await current(session)).toEqual(path);
@@ -2240,7 +2256,16 @@ export function runPluginContract(plugin, fixture) {
                     });
                 });
             });
-            it("givenActiveQuery_whenCancel_thenQueryCancelled", async () => {
+            it.runIf(fixture.sessions?.cancels === false)("givenNoCancel_whenCancelSession_thenRejects", async () => {
+                await withMonitor(async (monitor) => {
+                    await withSleeper(async (sleeper) => {
+                        const row = await present(monitor, idOf(sleeper), (listed) => listed.state === "active");
+                        expect(row.cancel).toBeNull();
+                        expect(await rejectionCode(monitor.cancelSession({ id: row.id, instance: row.instance }))).toBe("statementFailed");
+                    });
+                });
+            });
+            it.runIf(fixture.sessions?.cancels !== false)("givenActiveQuery_whenCancel_thenQueryCancelled", async () => {
                 await withMonitor(async (monitor) => {
                     await withSleeper(async (sleeper, running) => {
                         const row = await present(monitor, idOf(sleeper), (listed) => listed.state === "active");
@@ -2268,6 +2293,15 @@ export function runPluginContract(plugin, fixture) {
                 }
             });
             it("givenMissingSession_whenTerminate_thenRejects", async () => {
+                const missingId = sessionsFixture().missingId;
+                if (missingId !== undefined) {
+                    await withMonitor(async (monitor) => {
+                        const listed = await monitor.list();
+                        expect(listed.sessions.map((session) => session.id)).not.toContain(missingId);
+                        expect(await rejectionCode(monitor.terminateSession({ id: missingId, instance: null }))).toBe("statementFailed");
+                    });
+                    return;
+                }
                 const victim = await connect(plugin, fixture.config);
                 const id = idOf(victim);
                 await victim.close();

package/dist/url.d.ts

@@ -25,6 +25,7 @@ export interface ConnectionUrlSpec {
         readonly values?: Readonly<Record<string, string>> | undefined;
     }[] | undefined;
     readonly sets?: Readonly<Record<string, Readonly<Record<string, ConnectionValue>>>> | undefined;
+    readonly semicolonParams?: boolean | undefined;
 }
 interface UrlField {
     readonly key: string;

package/dist/url.js

@@ -9,6 +9,9 @@ const SCHEME = /^([a-zA-Z][a-zA-Z0-9+.-]*):/;
 const WINDOWS_DRIVE_PATH = /^\/[A-Za-z]:[/\\]/;
 const LEADING_SLASHES = /^\/+/;
 const LOCAL_HOSTS = new Set(["", "localhost"]);
+/** `host`, `[v6]`, then SQL Server's `\instance` and the port, as the JDBC driver reads them. */
+const SEMICOLON_AUTHORITY = /^(\[[^\]]*\]|[^\\:]*)(?:\\([^:]*))?(?::([^:]*))?$/;
+const INSTANCE_PARAM = "instanceName";
 /** libpq's names for the parts of the URL, accepted as query parameters by every server form. */
 const PART_PARAMS = {
     host: "host",
@@ -104,6 +107,8 @@ function parseServer(form, url, text) {
     if (scheme === undefined || !url.schemes.includes(scheme) || !text.slice(scheme.length + 1).startsWith("//")) {
         throw new ConnectionUrlError(`Expected a URL starting with ${schemeList(url)}.`);
     }
+    if (url.semicolonParams === true)
+        return parseSemicolon(form, url, scheme, text);
     let parsed;
     try {
         parsed = new URL(text);
@@ -121,6 +126,56 @@ function parseServer(form, url, text) {
     collected.query(parsed.search);
     return collected.done();
 }
+/** Splits on `;` outside `{…}`, which the JDBC driver uses to put a `;` in a value. */
+function semicolonPairs(text) {
+    const pairs = [];
+    let current = "";
+    let braced = false;
+    for (const char of text) {
+        if (char === "{")
+            braced = true;
+        else if (char === "}")
+            braced = false;
+        if (char === ";" && !braced) {
+            pairs.push(current);
+            current = "";
+        }
+        else
+            current += char;
+    }
+    pairs.push(current);
+    return pairs.filter((pair) => pair.trim() !== "");
+}
+function unbraced(value) {
+    const trimmed = value.trim();
+    return trimmed.startsWith("{") && trimmed.endsWith("}") ? trimmed.slice(1, -1) : trimmed;
+}
+function parseSemicolon(form, url, scheme, text) {
+    const [authority = "", ...pairs] = semicolonPairs(text.slice(scheme.length + "://".length));
+    const match = SEMICOLON_AUTHORITY.exec(authority.trim());
+    if (match === null) {
+        throw new ConnectionUrlError(`"${authority}" is not host, host\\instance or host:port.`);
+    }
+    const [, host = "", instance, port] = match;
+    if (port !== undefined && !/^\d+$/.test(port)) {
+        throw new ConnectionUrlError(`The port "${port}" is not a number.`);
+    }
+    const collected = new Collected(form, url);
+    Object.assign(collected.values, url.sets?.[scheme]);
+    collected.part("host", host.replace(/^\[(.*)\]$/, "$1"));
+    if (port !== undefined)
+        collected.part("port", port);
+    if (instance !== undefined && instance !== "")
+        collected.param(INSTANCE_PARAM, instance);
+    for (const pair of pairs) {
+        const equals = pair.indexOf("=");
+        if (equals < 0)
+            collected.ignored.push(pair.trim());
+        else
+            collected.param(pair.slice(0, equals).trim(), unbraced(pair.slice(equals + 1)));
+    }
+    return collected.done();
+}
 function parseFile(form, url, text) {
     const collected = new Collected(form, url);
     const scheme = SCHEME.exec(text)?.[1]?.toLowerCase();
@@ -175,6 +230,37 @@ function isConnectionValue(value) {
 function written(value) {
     return String(value);
 }
+function bracedValue(value) {
+    return /[;{}=]/.test(value) || value !== value.trim() ? `{${value}}` : value;
+}
+/** Every parameter after a `;`, one per field, so a part a parameter also names is written once. */
+function semicolonUrl(form, url, scheme, config) {
+    const text = (key) => {
+        if (key === undefined || fieldOf(form, key)?.secret === true)
+            return "";
+        const value = config[key];
+        return isConnectionValue(value) ? written(value) : "";
+    };
+    const host = text(url.parts.host);
+    const port = text(url.parts.port);
+    const pairs = [];
+    const keys = new Set([url.parts.host, url.parts.port]);
+    for (const param of url.params ?? []) {
+        if (keys.has(param.key))
+            continue;
+        keys.add(param.key);
+        const value = config[param.key];
+        const field = fieldOf(form, param.key);
+        if (field?.secret === true || !isConnectionValue(value) || value === "" || value === field?.default)
+            continue;
+        const shown = param.values === undefined
+            ? written(value)
+            : Object.entries(param.values).find(([, mapped]) => mapped === value)?.[0];
+        if (shown !== undefined)
+            pairs.push(`;${param.name}=${bracedValue(shown)}`);
+    }
+    return `${scheme}://${host.includes(":") ? `[${host}]` : host}${port === "" ? "" : `:${port}`}${pairs.join("")}`;
+}
 function encodedPath(path) {
     return encodeURI(path).replaceAll("?", "%3F").replaceAll("#", "%23");
 }
@@ -193,6 +279,8 @@ export function formatConnectionUrl(form, config) {
         url.schemes.find((candidate) => url.sets?.[candidate] === undefined) ??
         url.schemes[0] ??
         "";
+    if (url.semicolonParams === true)
+        return semicolonUrl(form, url, scheme, config);
     const valueOf = (part) => {
         const key = url.parts[part];
         if (key === undefined || fieldOf(form, key)?.secret === true)

package/dist/version.js

@@ -2,7 +2,7 @@
  * The plugin contract's version, by semver (decision 106): a host loads a plugin built for the same
  * major and an older or equal minor. Typed `string` so a bump does not change the API report.
  */
-export const API_VERSION = "1.3.0";
+export const API_VERSION = "1.5.0";
 const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
 /** `major.minor.patch` and nothing else; pre-release and build tags are not accepted. */
 export function parseVersion(text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablecraft-app/plugin-api",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "The datasource plugin contract for TableCraft",
   "license": "MIT",
   "type": "module",