fix(editor): move large SQL analysis off the input path
This commit is contained in:
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;
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
Reference in new issue
Block a user