fix(editor): move large SQL analysis off the input path

This commit is contained in:
t8y2 committed 2026-09-28 07:24:23 +08:00
1 parent 0a6ab8d360
commit adaaec5a3c
30 files changed
+1241 -211

No files matched your search

@@ -1,5 +1,5 @@
import { describe, expect, it } from "vitest";
import { QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH, shouldUseQueryEditorLargeDocumentMode } from "@/lib/editor/queryEditorLargeDocument";
import { QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH, QUERY_EDITOR_FULL_FEATURE_MAX_LINE_COUNT, shouldUseQueryEditorLargeDocumentMode, shouldUseQueryEditorLargeDocumentModeForSize } from "@/lib/editor/queryEditorLargeDocument";
describe("query editor large document policy", () => {
it("keeps the default feature set through the configured budget", () => {
@@ -9,4 +9,20 @@ describe("query editor large document policy", () => {
it("switches to bounded features above the configured budget", () => {
expect(shouldUseQueryEditorLargeDocumentMode("x".repeat(QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH + 1))).toBe(true);
});
it("keeps full features through the configured line budget", () => {
const document = Array.from({ length: QUERY_EDITOR_FULL_FEATURE_MAX_LINE_COUNT }, () => "SELECT 1;").join("\n");
expect(shouldUseQueryEditorLargeDocumentMode(document)).toBe(false);
expect(shouldUseQueryEditorLargeDocumentModeForSize(document.length, QUERY_EDITOR_FULL_FEATURE_MAX_LINE_COUNT)).toBe(false);
});
it("switches to bounded features above the configured line budget", () => {
const lineCount = QUERY_EDITOR_FULL_FEATURE_MAX_LINE_COUNT + 1;
const document = Array.from({ length: lineCount }, () => "SELECT 1;").join("\n");
expect(document.length).toBeLessThan(QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH);
expect(shouldUseQueryEditorLargeDocumentMode(document)).toBe(true);
expect(shouldUseQueryEditorLargeDocumentModeForSize(document.length, lineCount)).toBe(true);
});
});
@@ -0,0 +1,124 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { createSqlAnalysisWorker } from "@/lib/sql/sqlAnalysisWorker";
class ControlledWorker {
onmessage: Worker["onmessage"] = null;
onerror: Worker["onerror"] = null;
onmessageerror: Worker["onmessageerror"] = null;
postMessage = vi.fn();
terminate = vi.fn();
reply(id: number, result: string) {
this.onmessage?.call(this as unknown as Worker, { data: { id, result } } as MessageEvent);
}
fail() {
this.onerror?.call(this as unknown as Worker, {} as ErrorEvent);
}
}
afterEach(() => vi.unstubAllGlobals());
function harness() {
vi.stubGlobal("Worker", ControlledWorker);
const worker = new ControlledWorker();
const create = vi.fn(() => worker as unknown as Worker);
const fallback = vi.fn((input: string) => `fallback:${input}`);
const service = createSqlAnalysisWorker(create, fallback);
return { worker, create, fallback, service };
}
describe("SQL background analysis scheduling", () => {
it("does not run analysis on the UI thread and reuses the worker", async () => {
const { worker, create, fallback, service } = harness();
const first = service.analyze("first");
expect(fallback).not.toHaveBeenCalled();
worker.reply(1, "first result");
await expect(first).resolves.toBe("first result");
const second = service.analyze("second");
worker.reply(2, "second result");
await expect(second).resolves.toBe("second result");
expect(create).toHaveBeenCalledTimes(1);
service.dispose();
expect(worker.terminate).toHaveBeenCalledTimes(1);
});
it("keeps at most the running request and the newest queued edit", async () => {
const { worker, fallback, service } = harness();
const first = service.analyze("first");
const second = service.analyze("second");
const third = service.analyze("third");
await expect(first).resolves.toBeNull();
await expect(second).resolves.toBeNull();
expect(worker.postMessage).toHaveBeenCalledTimes(1);
worker.reply(1, "obsolete");
expect(worker.postMessage).toHaveBeenLastCalledWith({ id: 3, input: "third" });
worker.reply(2, "out of order");
worker.reply(3, "current");
await expect(third).resolves.toBe("current");
expect(fallback).not.toHaveBeenCalled();
service.dispose();
});
it("settles both requests when cancelled without losing the warm worker", async () => {
const { worker, create, service } = harness();
const first = service.analyze("first");
const second = service.analyze("second");
service.cancel();
await expect(first).resolves.toBeNull();
await expect(second).resolves.toBeNull();
worker.reply(1, "obsolete");
expect(worker.postMessage).toHaveBeenCalledTimes(1);
const next = service.analyze("next");
worker.reply(3, "next result");
await expect(next).resolves.toBe("next result");
expect(create).toHaveBeenCalledTimes(1);
service.dispose();
});
it("ignores late events after disposal", async () => {
const { worker, service, fallback } = harness();
const pending = service.analyze("pending");
service.dispose();
worker.reply(1, "late");
worker.fail();
await expect(pending).resolves.toBeNull();
expect(fallback).not.toHaveBeenCalled();
});
it("falls back only for the newest request when a worker fails", async () => {
const { worker, service, fallback } = harness();
const first = service.analyze("first");
const latest = service.analyze("latest");
worker.fail();
await expect(first).resolves.toBeNull();
await expect(latest).resolves.toBe("fallback:latest");
expect(fallback.mock.calls).toEqual([["latest"]]);
await expect(service.analyze("next")).resolves.toBe("fallback:next");
});
it("preserves functionality when worker construction or message cloning fails", async () => {
const { worker, service, fallback } = harness();
worker.postMessage.mockImplementation(() => {
throw new Error("clone failed");
});
await expect(service.analyze("clone")).resolves.toBe("fallback:clone");
const unavailable = createSqlAnalysisWorker(() => {
throw new Error("blocked by CSP");
}, fallback);
await expect(unavailable.analyze("CSP")).resolves.toBe("fallback:CSP");
});
it("uses the caller's editor-aware fallback and handles its exceptions", async () => {
vi.stubGlobal("Worker", undefined);
const create = vi.fn();
const service = createSqlAnalysisWorker<string, string>(create, () => "default");
await expect(service.analyze("SQL", () => "editor state")).resolves.toBe("editor state");
await expect(
service.analyze("invalid", () => {
throw new Error("invalid");
}),
).resolves.toBeNull();
expect(create).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,67 @@
import { EditorState } from "@codemirror/state";
import * as langSql from "@codemirror/lang-sql";
import { ensureSyntaxTree } from "@codemirror/language";
import { describe, expect, it } from "vitest";
import { createDbxCodeMirrorSqlDialect } from "@/lib/editor/codemirrorSqlDialect";
import { analyzeSqlCompletion, SqlCompletionAnalysisEngine, type SqlCompletionAnalysisRequest } from "@/lib/sql/sqlCompletionAnalysis";
import { analyzeSqlStatements } from "@/lib/sql/sqlStatementAnalysis";
import { executableStatementRangeCacheForDoc } from "@/lib/sql/executableStatementRangeCache";
import { analyzeSqlDiagnostics } from "@/lib/sql/sqlDiagnosticAnalysis";
import { sqlSemanticDiagnosticRangesForViewport, sqlServerRoutineDefinitionRangesForViewport } from "@/lib/sql/semantic/diagnostics";
import type { DatabaseType } from "@/types/database";
import { computeBlockFoldRanges } from "@/lib/editor/codemirrorSqlBlockFolding";
describe("background SQL completion parity", () => {
it.each([
["mysql", "WITH recent(id) AS (SELECT id FROM orders) SELECT recent. FROM recent"],
["postgres", "SELECT nextval('orders_id_seq')"],
["oracle", "SELECT * FROM orders@remote"],
["sqlserver", "USE reporting; SELECT * FROM dbo.orders WHERE "],
["mysql", "SELECT 'literal; still literal' -- comment"],
] as const)("preserves %s context and trigger policy", (databaseType, sql) => {
const dialect = databaseType === "oracle" ? "mysql" : databaseType;
const request: SqlCompletionAnalysisRequest = { sql, cursor: sql.indexOf("recent.") >= 0 ? sql.indexOf("recent.") + 7 : sql.length, databaseType, dialect, semanticCompletionEnabled: true };
const state = EditorState.create({ doc: sql, extensions: [langSql.sql({ dialect: createDbxCodeMirrorSqlDialect(langSql, dialect, databaseType) })] });
ensureSyntaxTree(state, sql.length, 1000);
const expected = analyzeSqlCompletion(request, state);
expect(new SqlCompletionAnalysisEngine().analyze(request)).toEqual(expected);
expect(structuredClone(expected)).toEqual(expected);
});
it("preserves distant CTE columns in an oversized statement", () => {
const sql = `WITH recent(id, total) AS (SELECT id, total FROM orders WHERE 1=1\n${"AND 1=1\n".repeat(5_000)}) SELECT recent. FROM recent`;
const engine = new SqlCompletionAnalysisEngine();
const request: SqlCompletionAnalysisRequest = { sql, cursor: sql.lastIndexOf("recent.") + 7, databaseType: "mysql", dialect: "mysql", semanticCompletionEnabled: true };
const result = engine.analyze(request);
expect(result.completionContext.qualifier).toBe("recent");
expect(result.cteDefinitions).toContainEqual({ name: "recent", columns: ["id", "total"] });
const edited = { ...request, sql: sql.slice(0, request.cursor) + "i" + sql.slice(request.cursor), cursor: request.cursor + 1 };
expect(engine.analyze(edited)).toEqual(new SqlCompletionAnalysisEngine().analyze(edited));
const replaced = { ...request, sql: "SELECT o. FROM orders o", cursor: 9 };
expect(engine.analyze(replaced)).toEqual(new SqlCompletionAnalysisEngine().analyze(replaced));
});
});
describe("background statement and diagnostic parity", () => {
it.each([
["postgres", "DO $body$ BEGIN PERFORM 1; PERFORM 2; END $body$;\nSELECT 3;"],
["mysql", "DELIMITER $$\nCREATE PROCEDURE p() BEGIN SELECT 1; SELECT 2; END$$\nDELIMITER ;\nSELECT 3;"],
["oracle", "BEGIN\n NULL;\n NULL;\nEND;\n/\nSELECT 3 FROM dual;"],
["sqlserver", "CREATE PROCEDURE p AS\nBEGIN\n SELECT 1;\n SELECT 2;\nEND\nGO\nSELECT 3;"],
["mysql", "/*+ optimizer hint */ SELECT #{value};\nSELECT 'escaped;literal';"],
] as const)("keeps exact %s execution boundaries and viewport diagnostics", (databaseType, sql) => {
const request = { sql, databaseType: databaseType as DatabaseType, parameterOptions: { enabledSyntaxes: ["mybatis" as const] } };
const { doc: _doc, ...expected } = executableStatementRangeCacheForDoc(null, EditorState.create({ doc: sql }).doc, databaseType, request.parameterOptions);
const result = structuredClone(analyzeSqlStatements(request));
expect(result).toEqual(expected);
const dialect = databaseType === "oracle" ? "mysql" : databaseType;
const state = EditorState.create({ doc: sql, extensions: [langSql.sql({ dialect: createDbxCodeMirrorSqlDialect(langSql, dialect, databaseType) })] });
ensureSyntaxTree(state, sql.length, 1000);
expect(analyzeSqlStatements({ ...request, includeFolds: true, syntaxDialect: dialect }).folds).toEqual(computeBlockFoldRanges(state, databaseType));
const visibleRanges = [{ from: 0, to: sql.length }];
const diagnostics = analyzeSqlDiagnostics({ ...request, cursor: 0, visibleRanges }).document!;
expect(diagnostics.shouldRun).toBe(true);
expect(diagnostics.diagnosticRanges).toEqual(sqlSemanticDiagnosticRangesForViewport(sql, visibleRanges, databaseType, undefined, request.parameterOptions));
expect(diagnostics.sqlServerRoutineRanges).toEqual(databaseType === "sqlserver" ? sqlServerRoutineDefinitionRangesForViewport(sql, visibleRanges) : []);
});
});
@@ -1,7 +1,7 @@
import * as langSql from "@codemirror/lang-sql";
import { ensureSyntaxTree, foldable } from "@codemirror/language";
import { ensureSyntaxTree, foldable, foldService } from "@codemirror/language";
import { Compartment, EditorState } from "@codemirror/state";
import { describe, expect, it } from "vitest";
import { describe, expect, it, vi } from "vitest";
import { createDbxCodeMirrorSqlDialect } from "@/lib/editor/codemirrorSqlDialect";
import { collectUnionBranchFoldRanges, createSqlBlockFoldService, sqlBlockFoldService } from "@/lib/editor/codemirrorSqlBlockFolding";
@@ -21,6 +21,20 @@ function foldedTextAtLine(state: EditorState, lineNumber: number): string | null
}
describe("sqlBlockFoldService", () => {
it("does not flatten SQL documents for REST request detection", () => {
const state = stateFor("BEGIN\n SELECT 1;\nEND", "mysql", createSqlBlockFoldService("mysql"));
const flatten = vi.spyOn(state.doc, "toString");
expect(foldedTextAtLine(state, 1)).toBe("\n SELECT 1;\n");
expect(flatten).not.toHaveBeenCalled();
});
it("uses background ranges without falling back to a synchronous scan", () => {
const cached = vi.fn(() => null);
const state = stateFor("BEGIN\n SELECT 1;\nEND", "mysql", createSqlBlockFoldService("mysql", cached));
const service = state.facet(foldService)[0];
expect(service(state, 0, state.doc.line(1).to)).toBeNull();
expect(cached).toHaveBeenCalled();
});
it.each(["elasticsearch", "easysearch", "meilisearch"] as const)("folds one %s REST request without a semicolon", (databaseType) => {
const sql = `POST /orders/_search
{
@@ -1,14 +1,14 @@
import { foldService, syntaxTree } from "@codemirror/language";
import type { EditorState } from "@codemirror/state";
import { elasticsearchRestRequestRanges } from "@/lib/sql/sqlStatementRanges";
import type { DatabaseType } from "@/types/database";
import { isElasticsearchCompatibleDatabaseType, isMeilisearchDatabaseType, isSolrDatabaseType, type DatabaseType } from "@/types/database";
// `@lezer/common` is only a transitive dependency here (see sqlSyntaxTreeWindow.ts's comment on
// the same pattern), so derive the node types structurally instead of importing them.
type SyntaxNode = ReturnType<ReturnType<typeof syntaxTree>["resolve"]>;
type Tree = ReturnType<typeof syntaxTree>;
interface FoldRange {
export interface FoldRange {
from: number;
to: number;
}
@@ -151,6 +151,7 @@ function addQueryStructureFoldRanges(state: EditorState, tree: Tree, ranges: Map
}
function addRestRequestFoldRanges(state: EditorState, ranges: Map<number, FoldRange>, databaseType?: DatabaseType): boolean {
if (databaseType && !isElasticsearchCompatibleDatabaseType(databaseType) && !isMeilisearchDatabaseType(databaseType) && !isSolrDatabaseType(databaseType)) return false;
const requests = elasticsearchRestRequestRanges(state.doc.toString(), databaseType ?? "elasticsearch");
if (requests.length === 0) return false;
@@ -160,8 +161,7 @@ function addRestRequestFoldRanges(state: EditorState, ranges: Map<number, FoldRa
return true;
}
function computeBlockFoldRanges(state: EditorState, databaseType?: DatabaseType): Map<number, FoldRange> {
const tree = syntaxTree(state);
export function computeBlockFoldRanges(state: EditorState, databaseType?: DatabaseType, tree: Tree = syntaxTree(state)): Map<number, FoldRange> {
const cacheByDatabaseType = rangeCache.get(tree);
const cacheKey = databaseType ?? "auto-detect";
const cached = cacheByDatabaseType?.get(cacheKey);
@@ -220,9 +220,11 @@ function computeBlockFoldRanges(state: EditorState, databaseType?: DatabaseType)
}
/** Creates folding for REST requests, procedural blocks, query parentheses, and UNION branches. */
export function createSqlBlockFoldService(databaseType?: DatabaseType) {
export function createSqlBlockFoldService(databaseType?: DatabaseType | (() => DatabaseType | undefined), cachedRange?: (state: EditorState, lineStart: number) => FoldRange | null | undefined) {
return foldService.of((state, lineStart) => {
const range = computeBlockFoldRanges(state, databaseType).get(state.doc.lineAt(lineStart).number);
const cached = cachedRange?.(state, lineStart);
if (cached !== undefined) return cached;
const range = computeBlockFoldRanges(state, typeof databaseType === "function" ? databaseType() : databaseType).get(state.doc.lineAt(lineStart).number);
return range ?? null;
});
}
@@ -1,5 +1,16 @@
export const QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH = 1024 * 1024;
export const QUERY_EDITOR_FULL_FEATURE_MAX_LINE_COUNT = 2_000;
export function shouldUseQueryEditorLargeDocumentModeForSize(documentLength: number, lineCount: number): boolean {
return documentLength > QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH || lineCount > QUERY_EDITOR_FULL_FEATURE_MAX_LINE_COUNT;
}
export function shouldUseQueryEditorLargeDocumentMode(document: string): boolean {
return document.length > QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH;
if (document.length > QUERY_EDITOR_FULL_FEATURE_MAX_DOCUMENT_LENGTH) return true;
let lineCount = 1;
for (let offset = document.indexOf("\n"); offset >= 0; offset = document.indexOf("\n", offset + 1)) {
lineCount += 1;
if (lineCount > QUERY_EDITOR_FULL_FEATURE_MAX_LINE_COUNT) return true;
}
return false;
}
@@ -1,4 +1,4 @@
import type { ChangeSet, Text } from "@codemirror/state";
import { RangeSet, RangeValue, type ChangeSet, type Text } from "@codemirror/state";
import type { DatabaseType } from "@/types/database";
import { readSqlBracedParameterAt, type SqlParameterOptions } from "@/lib/sql/sqlParameters";
import { executableStatementRanges, type SqlTextRange } from "@/lib/sql/sqlStatementRanges";
@@ -22,26 +22,42 @@ export interface ExecutableStatementRangeCache {
* the whole document synchronously per keystroke.
*/
export interface StatementGutterStartIndex {
starts: ReadonlySet<number>;
executableLineStarts: ReadonlySet<number>;
starts: RangeSet<StatementGutterStartMarker>;
executableLineStarts: RangeSet<StatementGutterStartMarker>;
}
class StatementGutterStartMarker extends RangeValue {
startSide = 1;
endSide = 1;
}
const statementGutterStartMarker = new StatementGutterStartMarker();
function statementGutterStartRangeSet(positions: Iterable<number>): RangeSet<StatementGutterStartMarker> {
return RangeSet.of(
Array.from(new Set(positions), (position) => statementGutterStartMarker.range(position)),
true,
);
}
export function statementGutterStartIndexForCache(cache: ExecutableStatementRangeCache): StatementGutterStartIndex {
return { starts: new Set(cache.byStart.keys()), executableLineStarts: new Set(cache.byExecutableLineStart.keys()) };
return {
starts: statementGutterStartRangeSet(cache.byStart.keys()),
executableLineStarts: statementGutterStartRangeSet(cache.byExecutableLineStart.keys()),
};
}
export function mapStatementGutterStartIndex(index: StatementGutterStartIndex, changes: ChangeSet): StatementGutterStartIndex {
return { starts: mapStartPositions(index.starts, changes), executableLineStarts: mapStartPositions(index.executableLineStarts, changes) };
}
function mapStartPositions(positions: ReadonlySet<number>, changes: ChangeSet): Set<number> {
const mapped = new Set<number>();
for (const position of positions) mapped.add(changes.mapPos(position, 1));
return mapped;
return { starts: index.starts.map(changes), executableLineStarts: index.executableLineStarts.map(changes) };
}
export function statementGutterStartIndexHasStartAt(index: StatementGutterStartIndex, lineFrom: number): boolean {
return index.starts.has(lineFrom) || index.executableLineStarts.has(lineFrom);
return rangeSetHasPointAt(index.starts, lineFrom) || rangeSetHasPointAt(index.executableLineStarts, lineFrom);
}
function rangeSetHasPointAt(ranges: RangeSet<StatementGutterStartMarker>, position: number): boolean {
const cursor = ranges.iter(position);
return cursor.value !== null && cursor.from === position;
}
export type ExecutableStatementRangeParser = (sql: string, databaseType?: DatabaseType, parameterOptions?: SqlParameterOptions) => SqlTextRange[];
@@ -0,0 +1,98 @@
export interface SqlAnalysisWorker<Input, Result> {
analyze: (input: Input, fallback?: () => Result) => Promise<Result | null>;
cancel: () => void;
dispose: () => void;
}
export function createSqlAnalysisWorker<Input, Result>(createWorker: () => Worker, analyzeLocally: (input: Input) => Result): SqlAnalysisWorker<Input, Result> {
interface Request {
id: number;
input: Input;
fallback: () => Result;
resolve: (result: Result | null) => void;
cancelled: boolean;
}
let worker: Worker | null = null;
let unavailable = typeof Worker === "undefined";
let nextId = 0;
let active: Request | null = null;
let queued: Request | null = null;
function fallback(request: Request) {
if (request.cancelled) return;
try {
request.resolve(request.fallback());
} catch {
request.resolve(null);
}
}
function finish(result: Result | null) {
active?.resolve(result);
active = null;
const next = queued;
queued = null;
if (next) start(next);
}
function fail() {
worker?.terminate();
worker = null;
unavailable = true;
if (active && !queued) fallback(active);
finish(null);
}
function start(request: Request) {
if (unavailable) {
fallback(request);
return;
}
active = request;
try {
if (!worker) {
const currentWorker = createWorker();
worker = currentWorker;
worker.onmessage = (event: MessageEvent<{ id: number; result?: Result; error?: string }>) => {
if (worker !== currentWorker || event.data.id !== active?.id) return;
if (event.data.error && !queued) fallback(active);
finish(event.data.result ?? null);
};
worker.onerror = worker.onmessageerror = () => {
if (worker === currentWorker) fail();
};
}
worker.postMessage({ id: request.id, input: request.input });
} catch {
fail();
}
}
function cancel() {
if (active) {
active.cancelled = true;
active.resolve(null);
}
queued?.resolve(null);
queued = null;
}
return {
analyze(input, localFallback = () => analyzeLocally(input)) {
cancel();
return new Promise((resolve) => {
const request = { id: ++nextId, input, fallback: localFallback, resolve, cancelled: false };
if (active) queued = request;
else start(request);
});
},
cancel,
dispose() {
cancel();
worker?.terminate();
worker = null;
active = null;
},
};
}
+2 -2
View File
@@ -1816,7 +1816,7 @@ class SqlCompletionProvider {
}
}
export function shouldAutoOpenSqlCompletion(sql: string, cursor: number, options: SqlSemanticBuildOptions = {}): boolean {
export function shouldAutoOpenSqlCompletion(sql: string, cursor: number, options: SqlSemanticBuildOptions = {}, precomputedContext?: SqlCompletionContext): boolean {
if (getPostgresSequenceLiteralCompletionContext(sql, cursor, options.databaseType)) return true;
if (isSqlCompletionSuppressedContext(sql, cursor, options)) return false;
const previousChar = sql[cursor - 1];
@@ -1830,7 +1830,7 @@ export function shouldAutoOpenSqlCompletion(sql: string, cursor: number, options
if (/\bon\s+$/i.test(beforeCursor)) return true;
if (isAfterJoinModifierContext(beforeCursor, options.databaseType)) return true;
if (/\bcall\s+(?:[A-Za-z_][\w$]*\.)?$/i.test(beforeCursor)) return true;
const context = getSqlCompletionContext(sql, cursor, options);
const context = precomputedContext ?? getSqlCompletionContext(sql, cursor, options);
if (previousChar === "(" && (context.insertTable || context.preferredValueKeywords?.length)) return true;
if (/[,;()[\]]/.test(previousChar)) return false;
if (context.exclusiveTableSuggestions || context.exclusiveRoutineSuggestions || context.suggestTables) {
@@ -0,0 +1,96 @@
import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
import { EditorState } from "@codemirror/state";
import * as langSql from "@codemirror/lang-sql";
import { createDbxCodeMirrorSqlDialect, type CodeMirrorSqlDialectName } from "@/lib/editor/codemirrorSqlDialect";
import { extractCteDefinitions, getSqlCompletionContext, getPostgresSequenceLiteralCompletionContext, isSqlCompletionSuppressedContext, shouldAutoOpenSqlCompletion, type SqlCompletionContext } from "@/lib/sql/sqlCompletion";
import { oracleDatabaseLinkCompletionContext } from "./oracleDatabaseLinkCompletion";
import { resolveSqlServerUseDatabaseCompletion } from "./sqlCompletionLookupTarget";
import { sqlCompletionContextFromSemantic } from "@/lib/sql/semantic/completion";
import { buildSqlSemanticModel } from "@/lib/sql/semantic/model";
import type { DatabaseType } from "@/types/database";
import type { SqlSemanticBuildOptions } from "./semantic/types";
export interface SqlCompletionAnalysisRequest {
sql: string;
cursor: number;
databaseType?: DatabaseType;
dialect?: SqlSemanticBuildOptions["dialect"];
semanticCompletionEnabled: boolean;
driverProfile?: string;
syntaxDialect?: CodeMirrorSqlDialectName;
}
export interface SqlCompletionAnalysisResult {
completionContext: SqlCompletionContext;
positionalEligible: boolean;
suppressed: boolean;
sequenceLiteralContext: ReturnType<typeof getPostgresSequenceLiteralCompletionContext>;
databaseLinkContext: ReturnType<typeof oracleDatabaseLinkCompletionContext>;
useDatabaseCompletion: ReturnType<typeof resolveSqlServerUseDatabaseCompletion>;
cteDefinitions: ReturnType<typeof extractCteDefinitions>;
}
function minimalDocumentChange(previous: string, next: string): { from: number; to: number; insert: string } | null {
if (previous === next) return null;
const sharedLimit = Math.min(previous.length, next.length);
let from = 0;
while (from < sharedLimit && previous.charCodeAt(from) === next.charCodeAt(from)) from += 1;
let previousTo = previous.length;
let nextTo = next.length;
while (previousTo > from && nextTo > from && previous.charCodeAt(previousTo - 1) === next.charCodeAt(nextTo - 1)) {
previousTo -= 1;
nextTo -= 1;
}
return { from, to: previousTo, insert: next.slice(from, nextTo) };
}
export class SqlCompletionAnalysisEngine {
private state: EditorState | null = null;
private document = "";
private dialectKey = "";
analyze(request: SqlCompletionAnalysisRequest): SqlCompletionAnalysisResult {
return analyzeSqlCompletion(request, this.editorStateFor(request));
}
private editorStateFor(request: SqlCompletionAnalysisRequest): EditorState {
const dialectName = request.syntaxDialect ?? (request.dialect === "doris" ? "mysql" : request.dialect) ?? "mysql";
const dialectKey = `${request.databaseType ?? ""}:${dialectName}:${request.driverProfile ?? ""}`;
if (!this.state || this.dialectKey !== dialectKey) {
this.state = EditorState.create({
doc: request.sql,
extensions: [langSql.sql({ dialect: createDbxCodeMirrorSqlDialect(langSql, dialectName, request.databaseType, request.driverProfile) })],
});
this.document = request.sql;
this.dialectKey = dialectKey;
} else {
const change = minimalDocumentChange(this.document, request.sql);
if (change) this.state = this.state.update({ changes: change }).state;
this.document = request.sql;
}
let tree = ensureSyntaxTree(this.state, this.state.doc.length, 250);
while (!tree) tree = ensureSyntaxTree(this.state, this.state.doc.length, 250);
if (tree !== syntaxTree(this.state)) this.state = this.state.update({}).state;
return this.state;
}
}
export function analyzeSqlCompletion(request: SqlCompletionAnalysisRequest, editorState?: EditorState): SqlCompletionAnalysisResult {
const options = {
databaseType: request.databaseType,
dialect: request.dialect,
editorState,
};
const legacyContext = getSqlCompletionContext(request.sql, request.cursor, options);
const completionContext = request.semanticCompletionEnabled ? sqlCompletionContextFromSemantic(buildSqlSemanticModel(request.sql, request.cursor, options), legacyContext) : legacyContext;
return {
completionContext,
positionalEligible: shouldAutoOpenSqlCompletion(request.sql, request.cursor, options, legacyContext),
suppressed: isSqlCompletionSuppressedContext(request.sql, request.cursor, options),
sequenceLiteralContext: getPostgresSequenceLiteralCompletionContext(request.sql, request.cursor, request.databaseType),
databaseLinkContext: oracleDatabaseLinkCompletionContext(request.sql, request.cursor, request.databaseType),
useDatabaseCompletion: resolveSqlServerUseDatabaseCompletion({ sql: request.sql, cursor: request.cursor, databaseType: request.databaseType }),
cteDefinitions: extractCteDefinitions(request.sql),
};
}
@@ -0,0 +1,16 @@
import { SqlCompletionAnalysisEngine, type SqlCompletionAnalysisRequest } from "./sqlCompletionAnalysis";
interface SqlCompletionAnalysisWorkerRequest {
id: number;
input: SqlCompletionAnalysisRequest;
}
const engine = new SqlCompletionAnalysisEngine();
self.onmessage = (event: MessageEvent<SqlCompletionAnalysisWorkerRequest>) => {
try {
self.postMessage({ id: event.data.id, result: engine.analyze(event.data.input) });
} catch (error) {
self.postMessage({ id: event.data.id, error: error instanceof Error ? error.message : String(error) });
}
};
@@ -0,0 +1,11 @@
import type { EditorState } from "@codemirror/state";
import { analyzeSqlCompletion, type SqlCompletionAnalysisRequest } from "./sqlCompletionAnalysis";
import { createSqlAnalysisWorker } from "./sqlAnalysisWorker";
export function createSqlCompletionAnalysisWorker() {
const worker = createSqlAnalysisWorker(() => new Worker(new URL("./sqlCompletionAnalysis.worker.ts", import.meta.url), { type: "module" }), analyzeSqlCompletion);
return {
...worker,
analyze: (input: SqlCompletionAnalysisRequest, editorState?: EditorState) => worker.analyze(input, () => analyzeSqlCompletion(input, editorState)),
};
}
@@ -0,0 +1,48 @@
import type { DatabaseType, SqlReferenceAnalysis } from "@/types/database";
import { buildOracleSyntaxDiagnostics } from "./oracleSyntaxDiagnostics";
import { analyzeMysqlRoutineSyntax, supportsMysqlRoutineSyntaxDiagnostics } from "./mysqlRoutineSyntaxDiagnostics";
import { buildSqlServerRoutineSyntaxDiagnostics } from "./sqlServerRoutineSyntaxDiagnostics";
import { isSqlSemanticDiagnosticInputContext, shouldRunSqlSemanticDiagnostics, sqlSemanticDiagnosticRangesForViewport, sqlServerRoutineDefinitionRangesForViewport } from "./semantic/diagnostics";
import { buildSqlSemanticModel } from "./semantic/model";
import { mergeSqlSemanticReferenceAnalysis } from "./semantic/references";
import type { SqlSemanticBuildOptions } from "./semantic/types";
import type { SqlParameterOptions } from "./sqlParameters";
export interface SqlDiagnosticAnalysisRequest {
sql: string;
cursor: number;
databaseType?: DatabaseType;
dialect?: SqlSemanticBuildOptions["dialect"];
driverProfile?: string;
parameterOptions?: SqlParameterOptions;
visibleRanges: readonly { from: number; to: number }[];
referenceAnalysis?: SqlReferenceAnalysis;
}
export function analyzeSqlDiagnosticDocument(request: SqlDiagnosticAnalysisRequest) {
const { sql, cursor, databaseType, visibleRanges, parameterOptions } = request;
const shouldRun = shouldRunSqlSemanticDiagnostics(sql, cursor, { databaseType });
const diagnosticRanges = shouldRun ? sqlSemanticDiagnosticRangesForViewport(sql, visibleRanges, databaseType, undefined, parameterOptions) : [];
const sqlServerRoutineRanges = shouldRun && databaseType === "sqlserver" ? sqlServerRoutineDefinitionRangesForViewport(sql, visibleRanges) : [];
return {
shouldRun,
inputContext: shouldRun && isSqlSemanticDiagnosticInputContext(sql, cursor, { databaseType }),
diagnosticRanges,
sqlServerRoutineRanges,
oracleSyntaxDiagnostics: shouldRun ? buildOracleSyntaxDiagnostics(sql, databaseType) : [],
mysqlRoutineAnalysis: shouldRun && databaseType === "mysql" && supportsMysqlRoutineSyntaxDiagnostics(request.driverProfile) ? analyzeMysqlRoutineSyntax(sql) : null,
sqlServerRoutineDiagnostics: sqlServerRoutineRanges.map((range) => buildSqlServerRoutineSyntaxDiagnostics(range.sql, databaseType)),
};
}
export interface SqlDiagnosticAnalysisResult {
document?: ReturnType<typeof analyzeSqlDiagnosticDocument>;
referenceAnalysis?: SqlReferenceAnalysis;
}
export function analyzeSqlDiagnostics(request: SqlDiagnosticAnalysisRequest): SqlDiagnosticAnalysisResult {
if (request.referenceAnalysis) {
return { referenceAnalysis: mergeSqlSemanticReferenceAnalysis(request.referenceAnalysis, buildSqlSemanticModel(request.sql, request.cursor, { databaseType: request.databaseType, dialect: request.dialect })) };
}
return { document: analyzeSqlDiagnosticDocument(request) };
}
@@ -0,0 +1,9 @@
import { analyzeSqlDiagnostics, type SqlDiagnosticAnalysisRequest } from "./sqlDiagnosticAnalysis";
self.onmessage = (event: MessageEvent<{ id: number; input: SqlDiagnosticAnalysisRequest }>) => {
try {
self.postMessage({ id: event.data.id, result: analyzeSqlDiagnostics(event.data.input) });
} catch (error) {
self.postMessage({ id: event.data.id, error: error instanceof Error ? error.message : String(error) });
}
};
@@ -0,0 +1,6 @@
import { analyzeSqlDiagnostics } from "./sqlDiagnosticAnalysis";
import { createSqlAnalysisWorker } from "./sqlAnalysisWorker";
export function createSqlDiagnosticAnalysisWorker() {
return createSqlAnalysisWorker(() => new Worker(new URL("./sqlDiagnosticAnalysis.worker.ts", import.meta.url), { type: "module" }), analyzeSqlDiagnostics);
}
@@ -0,0 +1,30 @@
import { EditorState, Text } from "@codemirror/state";
import * as langSql from "@codemirror/lang-sql";
import { ensureSyntaxTree } from "@codemirror/language";
import { createDbxCodeMirrorSqlDialect, type CodeMirrorSqlDialectName } from "@/lib/editor/codemirrorSqlDialect";
import { computeBlockFoldRanges, type FoldRange } from "@/lib/editor/codemirrorSqlBlockFolding";
import { executableStatementRangeCacheForDoc, type ExecutableStatementRangeCache } from "./executableStatementRangeCache";
import type { SqlParameterOptions } from "./sqlParameters";
import type { DatabaseType } from "@/types/database";
export interface SqlStatementAnalysisRequest {
sql: string;
databaseType?: DatabaseType;
parameterOptions?: SqlParameterOptions;
includeFolds?: boolean;
syntaxDialect?: CodeMirrorSqlDialectName;
driverProfile?: string;
}
export type SqlStatementAnalysisResult = Omit<ExecutableStatementRangeCache, "doc"> & { folds?: Map<number, FoldRange> };
export function analyzeSqlStatements(request: SqlStatementAnalysisRequest): SqlStatementAnalysisResult {
const { doc: _doc, ...result } = executableStatementRangeCacheForDoc(null, Text.of(request.sql.split("\n")), request.databaseType, request.parameterOptions);
if (request.includeFolds) {
const state = EditorState.create({ doc: request.sql, extensions: [langSql.sql({ dialect: createDbxCodeMirrorSqlDialect(langSql, request.syntaxDialect ?? "mysql", request.databaseType, request.driverProfile) })] });
let tree = ensureSyntaxTree(state, state.doc.length, 1000);
while (!tree) tree = ensureSyntaxTree(state, state.doc.length, 1000);
return { ...result, folds: computeBlockFoldRanges(state, request.databaseType, tree) };
}
return result;
}
@@ -0,0 +1,9 @@
import { analyzeSqlStatements, type SqlStatementAnalysisRequest } from "./sqlStatementAnalysis";
self.onmessage = (event: MessageEvent<{ id: number; input: SqlStatementAnalysisRequest }>) => {
try {
self.postMessage({ id: event.data.id, result: analyzeSqlStatements(event.data.input) });
} catch (error) {
self.postMessage({ id: event.data.id, error: error instanceof Error ? error.message : String(error) });
}
};
@@ -0,0 +1,6 @@
import { analyzeSqlStatements } from "./sqlStatementAnalysis";
import { createSqlAnalysisWorker } from "./sqlAnalysisWorker";
export function createSqlStatementAnalysisWorker() {
return createSqlAnalysisWorker(() => new Worker(new URL("./sqlStatementAnalysis.worker.ts", import.meta.url), { type: "module" }), analyzeSqlStatements);
}