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,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);
}