Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

30.3 KB
Raw Blame
import type { CompletionContext } from "@codemirror/autocomplete";
import { syntaxTreeAvailable } from "@codemirror/language";
import { type QueryCompletionOption } from "./useQueryEditorBatchSelection";
import { type SqlTextRange } from "@/lib/sql/sqlStatementRanges";
import { executableStatementRangeCacheForDoc, statementGutterStartIndexHasStartAt } from "@/lib/sql/executableStatementRangeCache";
import { createDeferredEditorTask } from "@/lib/editor/deferredEditorTask";
import { currentStatementFrameRangeTo } from "@/lib/sql/currentStatementFrame";
import { expandToSqlStatementWindow } from "@/lib/sql/insertValueHints";
import { createSqlSignatureTooltipDom } from "@/lib/editor/sqlSignatureTooltip";
import { getSqlFunctionSignatureHelp } from "@/lib/sql/sqlCompletion";
import { shellLineCommentTheme, sqlSemanticHighlightTheme } from "@/lib/editor/editorThemes";
import { createStatementGutterMarkerDom } from "@/lib/editor/codemirrorStatementGutter";
import { compareSqlCompletions } from "@/lib/editor/sqlCompletionPresentation";
import { currentStatementFrameLayer } from "@/lib/editor/codemirrorCurrentStatementFrameLayer";
import { createSqlAliasHighlights } from "@/lib/editor/codemirrorSqlAliasHighlights";
import { createDbxCodeMirrorSqlDialect, supportsQueryEditorSqlLanguage } from "@/lib/editor/codemirrorSqlDialect";
import { graphQueryLanguage, isGraphQueryDatabase } from "@/lib/graph/graphQueryLanguage";
import { getGraphFunctionSignatureHelp } from "@/lib/graph/graphSignatureHelp";
import { sqlSemanticTableNameSpansForSyntaxTree } from "@/lib/editor/codemirrorSqlSemanticHighlight";
import { queryEditorCommentTokens, queryEditorLineCommentToken, queryEditorWordLanguageData } from "@/lib/editor/queryEditorLineComment";
import { queryEditorStatementDatabaseType } from "@/lib/mongo/mongoSql";
import { createShellLineCommentHighlight } from "@/lib/editor/codemirrorShellLineCommentHighlight";
import type { StatementExecutionMarker } from "@/lib/tabs/tabPresentation";
import { resolveSqlDialectId } from "@/lib/sql/semantic/dialect";
import type { DatabaseType } from "@/types/database";
import type { ComputedRef } from "vue";
import type { EditorView as EditorViewType } from "@codemirror/view";
import type { Composer } from "vue-i18n";
import type { useSettingsStore } from "@/stores/settingsStore";
import type { QueryEditorProps } from "./queryEditorTypes";
import type { QueryEditorCodeMirrorRuntime, QueryEditorCodeMirrorModules } from "./queryEditorCodeMirrorRuntime";
import type { useQueryEditorDiagnostics } from "./useQueryEditorDiagnostics";
import type { useQueryEditorCompletion } from "./useQueryEditorCompletion";
import type { useQueryEditorBatchSelection } from "./useQueryEditorBatchSelection";
import type { useQueryEditorStatementBoundaries } from "./useQueryEditorStatementBoundaries";
import type { ExecutableStatementRangeCache } from "@/lib/sql/executableStatementRangeCache";
import type { SqlParameterOptions } from "@/lib/sql/sqlParameters";

interface QueryEditorSqlExtensionsOptions {
  props: Readonly<QueryEditorProps>;
  runtime: QueryEditorCodeMirrorRuntime;
  modules: QueryEditorCodeMirrorModules;
  settingsStore: ReturnType<typeof useSettingsStore>;
  t: Composer["t"];
  sqlBehaviorDialect: () => QueryEditorProps["dialect"];
  sqlDriverProfile: ComputedRef<string | undefined>;
  sqlFunctionDatabaseType?: () => DatabaseType | undefined;
  sqlSyntaxDialect?: () => QueryEditorProps["syntaxDialect"];
  sqlStatementParameterOptions: () => SqlParameterOptions;
  queryEditorSelectionLanguage: () => "sql" | "text";
  cache: { value: ExecutableStatementRangeCache | null };
  completion: ReturnType<typeof useQueryEditorCompletion>;
  batchSelection: ReturnType<typeof useQueryEditorBatchSelection>;
  diagnostics: Pick<ReturnType<typeof useQueryEditorDiagnostics>, "sqlErrorDecorationRange" | "sqlSemanticDecorationRanges">;
  statementBoundaries: ReturnType<typeof useQueryEditorStatementBoundaries>;
  currentExecutableStatementRange: (view: EditorViewType) => SqlTextRange | null;
  executeSqlStatementFromGutter: (view: EditorViewType, line: { from: number; to: number }, event: Event) => boolean;
  signatureHelpWindowChars: number;
  boundedAnalysisEnabled: () => boolean;
}

export function configureQueryEditorSqlExtensions(options: QueryEditorSqlExtensionsOptions) {
  const { props, runtime: codeMirrorRuntime, settingsStore, t, sqlBehaviorDialect, sqlDriverProfile, sqlStatementParameterOptions, queryEditorSelectionLanguage, cache, batchSelection, currentExecutableStatementRange, executeSqlStatementFromGutter, boundedAnalysisEnabled } = options;
  const { EditorView, Decoration, StateField, StateEffect, GutterMarker, RangeSet, lineNumberMarkers, gutter, showTooltip, autocompletion, ViewPlugin, highlightingFor, syntaxTree, langSql, Prec, EditorState, ensureSyntaxTree, layer, RectangleMarker } = options.modules;
  const { provideSqlCompletions } = options.completion;
  const { renderBatchColumnSelectionActionMarker, renderBatchColumnSelectionCheckbox } = batchSelection;
  const { sqlErrorDecorationRange, sqlSemanticDecorationRanges } = options.diagnostics;
  const { statementBoundariesForState } = options.statementBoundaries;
  const SQL_SIGNATURE_HELP_WINDOW_CHARS = options.signatureHelpWindowChars;

  const diagnosticTheme = EditorView.baseTheme({
    ".cm-sql-error": {
      textDecoration: "underline wavy var(--dbx-editor-diagnostic-error, var(--destructive))",
      textUnderlineOffset: "3px",
    },
    ".cm-sql-semantic-warning": {
      textDecoration: "underline wavy var(--dbx-editor-diagnostic-warning, var(--warning))",
      textUnderlineOffset: "3px",
    },
  });

  codeMirrorRuntime.buildSqlDiagnosticExtension = () => {
    const diagnosticEffect = codeMirrorRuntime.setSqlDiagnosticsEffect;
    const buildDecorations = (state: import("@codemirror/state").EditorState) => {
      const errorDecorations = sqlErrorDecorationRange(state).map((range) =>
        Decoration.mark({
          class: "cm-sql-error",
          attributes: { title: range.message },
        }).range(range.from, range.to),
      );
      const semanticDecorations = sqlSemanticDecorationRanges(state).map((range) =>
        Decoration.mark({
          class: range.severity === "error" ? "cm-sql-error" : "cm-sql-semantic-warning",
          attributes: { title: range.message },
        }).range(range.from, range.to),
      );
      return Decoration.set([...errorDecorations, ...semanticDecorations], true);
    };

    const field = StateField.define({
      create: buildDecorations,
      update(value, transaction) {
        const diagnosticsChanged = !!diagnosticEffect && transaction.effects.some((effect) => effect.is(diagnosticEffect));
        if (diagnosticsChanged) return buildDecorations(transaction.state);
        if (transaction.docChanged) return Decoration.set([]);
        return value;
      },
      provide: (field) => EditorView.decorations.from(field),
    });

    return [field, diagnosticTheme];
  };

  codeMirrorRuntime.setPreviewRangeEffect = StateEffect.define<{
    from: number;
    to: number;
  } | null>();

  codeMirrorRuntime.buildPreviewRangeExtension = () => {
    const effectType = codeMirrorRuntime.setPreviewRangeEffect!;
    const field = StateField.define({
      create() {
        return Decoration.none;
      },
      update(decorations, transaction) {
        for (const effect of transaction.effects) {
          if (effect.is(effectType)) {
            const range = effect.value;
            if (!range) return Decoration.none;
            return Decoration.set([Decoration.mark({ class: "cm-db-execution-preview" }).range(range.from, range.to)]);
          }
        }
        if (transaction.docChanged || transaction.selection) return Decoration.none;
        return decorations;
      },
      provide: (f) => EditorView.decorations.from(f),
    });
    return field;
  };

  class ResultSourceLineNumberMarker extends GutterMarker {
    elementClass = "cm-db-result-source-line-number";
  }

  const resultSourceLineNumberMarker = new ResultSourceLineNumberMarker();

  codeMirrorRuntime.setResultSourceRangeEffect = StateEffect.define<{
    from: number;
    to: number;
  } | null>();

  codeMirrorRuntime.buildResultSourceRangeExtension = () => {
    const effectType = codeMirrorRuntime.setResultSourceRangeEffect!;
    const markersForRange = (state: import("@codemirror/state").EditorState, range: { from: number; to: number }) => {
      const from = Math.max(0, Math.min(range.from, state.doc.length));
      const to = Math.max(from, Math.min(range.to, state.doc.length));
      const startLine = state.doc.lineAt(from);
      const endLine = state.doc.lineAt(Math.max(from, to - 1));
      const markers = Array.from({ length: endLine.number - startLine.number + 1 }, (_, index) => resultSourceLineNumberMarker.range(state.doc.line(startLine.number + index).from));
      return RangeSet.of(markers);
    };

    const field = StateField.define({
      create() {
        return RangeSet.empty;
      },
      update(markers, transaction) {
        for (const effect of transaction.effects) {
          if (effect.is(effectType)) {
            return effect.value ? markersForRange(transaction.state, effect.value) : RangeSet.empty;
          }
        }
        if (transaction.docChanged || transaction.selection) return RangeSet.empty;
        return markers;
      },
      provide: (field) => lineNumberMarkers.from(field),
    });

    const highlightField = StateField.define({
      create() {
        return Decoration.none;
      },
      update(decorations, transaction) {
        for (const effect of transaction.effects) {
          if (effect.is(effectType)) {
            const range = effect.value;
            if (!range) return Decoration.none;
            const from = Math.max(0, Math.min(range.from, transaction.state.doc.length));
            const to = Math.max(from, Math.min(range.to, transaction.state.doc.length));
            return from === to ? Decoration.none : Decoration.set([Decoration.mark({ class: "cm-db-result-source-highlight" }).range(from, to)]);
          }
        }
        if (transaction.docChanged || transaction.selection) return Decoration.none;
        return decorations;
      },
      provide: (field) => EditorView.decorations.from(field),
    });
    return [field, highlightField];
  };

  class StatementExecutionStateMarker extends GutterMarker {
    constructor(readonly marker: StatementExecutionMarker) {
      super();
    }

    eq(other: import("@codemirror/view").GutterMarker): boolean {
      return other instanceof StatementExecutionStateMarker && other.marker.status === this.marker.status && other.marker.successCount === this.marker.successCount && other.marker.errorCount === this.marker.errorCount && other.marker.runningCount === this.marker.runningCount;
    }
  }

  class StatementGutterMarker extends GutterMarker {
    constructor(
      readonly canExecute: boolean,
      readonly marker?: StatementExecutionMarker,
    ) {
      super();
    }

    eq(other: import("@codemirror/view").GutterMarker): boolean {
      return (
        other instanceof StatementGutterMarker &&
        other.canExecute === this.canExecute &&
        other.marker?.status === this.marker?.status &&
        other.marker?.successCount === this.marker?.successCount &&
        other.marker?.errorCount === this.marker?.errorCount &&
        other.marker?.runningCount === this.marker?.runningCount
      );
    }

    toDOM() {
      return createStatementGutterMarkerDom({
        canExecute: this.canExecute,
        executeLabel: t("editor.contextMenu.executeCurrent"),
        status: this.marker?.status,
        statusLabel: this.marker ? statementExecutionMarkerTitle(this.marker) : undefined,
      });
    }
  }

  function statementExecutionMarkerTitle(marker: StatementExecutionMarker) {
    const parts = [];
    if ((marker.runningCount ?? 0) > 0) parts.push(t("editor.statementExecutionRunning", { count: marker.runningCount }));
    if (marker.successCount > 0) parts.push(t("editor.statementExecutionSucceeded", { count: marker.successCount }));
    if (marker.errorCount > 0) parts.push(t("editor.statementExecutionFailed", { count: marker.errorCount }));
    return parts.join(", ");
  }

  codeMirrorRuntime.setStatementExecutionMarkersEffect = StateEffect.define<StatementExecutionMarker[]>();

  codeMirrorRuntime.buildRunStatementGutterExtension = () => {
    const effectType = codeMirrorRuntime.setStatementExecutionMarkersEffect!;
    const showRunButtons = !props.hideExecutionControls && settingsStore.editorSettings.showStatementRunButtons;
    const markersForState = (state: import("@codemirror/state").EditorState, markers: readonly StatementExecutionMarker[]) => {
      const ranges = markers.map((marker) => {
        const from = Math.max(0, Math.min(marker.from, state.doc.length));
        return new StatementExecutionStateMarker(marker).range(state.doc.lineAt(from).from);
      });
      return RangeSet.of(ranges, true);
    };

    const field = StateField.define({
      create(state) {
        return markersForState(state, props.statementExecutionMarkers ?? []);
      },
      update(markers, transaction) {
        for (const effect of transaction.effects) {
          if (effect.is(effectType)) return markersForState(transaction.state, effect.value);
        }
        if (transaction.docChanged) return RangeSet.empty;
        return markers;
      },
      provide: (field) =>
        gutter({
          class: "cm-run-statement-gutter",
          markers: (currentView) => currentView.state.field(field),
          lineMarker(currentView, line, markers) {
            const executionMarker = markers.find((marker) => marker instanceof StatementExecutionStateMarker)?.marker;
            // Membership check against the lenient index (mapped through the
            // ChangeSet while typing) instead of a full-document re-parse per
            // keystroke. The click handler still resolves the exact range on
            // demand, so display-level approximation never affects execution.
            const canExecute = showRunButtons && statementGutterStartIndexHasStartAt(statementBoundariesForState(currentView.state).startsIndex, line.from);
            return canExecute || executionMarker ? new StatementGutterMarker(canExecute, executionMarker) : null;
          },
          lineMarkerChange(update) {
            // Redraw once the debounced full rebuild has landed.
            const refreshEffect = codeMirrorRuntime.statementBoundariesRefreshEffect;
            return !!refreshEffect && update.transactions.some((transaction) => transaction.effects.some((effect) => effect.is(refreshEffect)));
          },
          domEventHandlers: showRunButtons
            ? {
                mousedown: executeSqlStatementFromGutter,
              }
            : {},
        }),
    });
    return field;
  };

  codeMirrorRuntime.buildSqlSignatureExtension = () => {
    if (!supportsQueryEditorSqlLanguage(props.databaseType)) return [];
    return showTooltip.compute(["doc", "selection"], (currentState) => {
      const cursor = currentState.selection.main.head;
      // Signature detection only scans backward from the cursor, so window the
      // text instead of materializing the whole document prefix on every
      // keystroke — doc.toString() was O(document) per key on large scripts.
      const windowFrom = Math.max(0, cursor - SQL_SIGNATURE_HELP_WINDOW_CHARS);
      const source = currentState.doc.sliceString(windowFrom, cursor);
      const signature = isGraphQueryDatabase(props.databaseType)
        ? getGraphFunctionSignatureHelp(source, cursor - windowFrom, props.databaseType, { truncatedPrefix: windowFrom > 0 })
        : getSqlFunctionSignatureHelp(source, cursor - windowFrom, options.sqlFunctionDatabaseType?.() ?? props.databaseType, sqlDriverProfile.value, { truncatedPrefix: windowFrom > 0 });
      if (!signature) return null;
      return {
        pos: cursor,
        above: false,
        clip: false,
        create: () => ({ dom: createSqlSignatureTooltipDom(signature) }),
      };
    });
  };

  codeMirrorRuntime.buildSqlCompletionExtension = () => {
    if (!supportsQueryEditorSqlLanguage(props.databaseType)) return [];
    return autocompletion({
      activateOnTyping: true,
      defaultKeymap: false,
      selectOnOpen: settingsStore.editorSettings.selectFirstCompletionOnOpen,
      compareCompletions: (a, b) => compareSqlCompletions(a, b, settingsStore.editorSettings.sortCompletionColumnsAlphabetically),
      // Keep normal completion lists virtualized; batch-field selection needs every row in the DOM.
      maxRenderedOptions: batchSelection.expandedRendering ? Number.MAX_SAFE_INTEGER : 100,
      optionClass: (completion) => ((completion as QueryCompletionOption).dbxBatchColumnSelectionAction ? "cm-batch-column-selection-action" : ""),
      addToOptions: [
        { position: 5, render: renderBatchColumnSelectionActionMarker },
        { position: 10, render: renderBatchColumnSelectionCheckbox },
      ],
      override: [async (context: CompletionContext) => provideSqlCompletions(context)],
    });
  };

  const shellLineCommentHighlightPlugin = createShellLineCommentHighlight({ ViewPlugin, Decoration, highlightingFor, syntaxTree });

  codeMirrorRuntime.buildSqlLanguageExtension = () => {
    const commentDatabaseType = queryEditorStatementDatabaseType(props.databaseType, props.mongoQueryLanguage);
    return [
      isGraphQueryDatabase(props.databaseType)
        ? graphQueryLanguage(props.databaseType)
        : supportsQueryEditorSqlLanguage(props.databaseType)
          ? langSql.sql({
              dialect: createDbxCodeMirrorSqlDialect(langSql, options.sqlSyntaxDialect?.() ?? props.syntaxDialect ?? props.dialect, props.databaseType, sqlDriverProfile.value),
            })
          : [],
      // Non-SQL editors (MongoDB shell) keep the SQL grammar for highlighting, so override the
      // comment marker that toggleLineComment reads from language data.
      Prec.highest(EditorState.languageData.of(() => [{ commentTokens: queryEditorCommentTokens(commentDatabaseType) }])),
      Prec.highest(EditorState.languageData.of(() => queryEditorWordLanguageData(options.sqlFunctionDatabaseType?.() ?? props.databaseType))),
      // The SQL grammar does not tokenize `//`, so those comments are highlighted by hand.
      queryEditorLineCommentToken(commentDatabaseType) === "//" ? shellLineCommentHighlightPlugin : [],
    ];
  };

  const MAX_SQL_SEMANTIC_HIGHLIGHT_WINDOWS = 32;

  const MAX_FULL_DOCUMENT_SQL_SEMANTIC_HIGHLIGHT_LENGTH = 128_000;

  const SQL_SEMANTIC_HIGHLIGHT_DEBOUNCE_MS = 100;

  const refreshSqlSemanticHighlightEffect = StateEffect.define<null>();

  codeMirrorRuntime.buildSqlSemanticHighlightExtension = () => {
    if (!supportsQueryEditorSqlLanguage(props.databaseType) || isGraphQueryDatabase(props.databaseType)) return [];
    return [
      createSqlAliasHighlights({ databaseType: props.databaseType, dialect: sqlBehaviorDialect(), enabled: queryEditorSelectionLanguage() === "sql" }),
      ViewPlugin.fromClass(
        class {
          decorations: import("@codemirror/view").DecorationSet;
          private refreshTask = createDeferredEditorTask(() => {
            if (this.currentView.dom.isConnected) this.currentView.dispatch({ effects: refreshSqlSemanticHighlightEffect.of(null) });
          }, SQL_SEMANTIC_HIGHLIGHT_DEBOUNCE_MS);
          private cachedDoc: import("@codemirror/state").Text | null = null;
          private prewarmedDoc: import("@codemirror/state").Text | null = null;
          private cachedSql = "";
          private cachedDialectId = "";
          private cachedDatabaseType: DatabaseType | undefined;
          private cachedWindows: Array<{
            from: number;
            to: number;
            spans: Array<{ start: number; end: number }>;
          }> = [];

          constructor(private currentView: import("@codemirror/view").EditorView) {
            this.decorations = Decoration.none;
            this.decorations = this.buildDecorations(currentView);
          }

          update(update: import("@codemirror/view").ViewUpdate) {
            const refreshRequested = update.transactions.some((transaction) => transaction.effects.some((effect) => effect.is(refreshSqlSemanticHighlightEffect)));
            if (update.docChanged) {
              this.decorations = this.decorations.map(update.changes);
              this.scheduleRefresh(update.view);
              return;
            }
            if (refreshRequested) {
              this.cancelRefresh();
              this.decorations = this.buildDecorations(update.view);
            } else if (update.viewportChanged) {
              // Keep existing decorations while scrolling. Parse only after the
              // viewport settles instead of blocking CodeMirror's layout update.
              this.scheduleRefresh(update.view);
            }
          }

          scheduleRefresh(currentView: import("@codemirror/view").EditorView) {
            this.currentView = currentView;
            this.refreshTask.schedule();
          }

          cancelRefresh() {
            this.refreshTask.cancel();
          }

          destroy() {
            this.cancelRefresh();
          }

          buildDecorations(currentView: import("@codemirror/view").EditorView) {
            const dialectId = resolveSqlDialectId({ databaseType: props.databaseType, dialect: sqlBehaviorDialect() });
            const doc = currentView.state.doc;
            if (this.cachedDoc !== doc || this.cachedDialectId !== dialectId || this.cachedDatabaseType !== props.databaseType) {
              this.cachedDoc = doc;
              this.cachedSql = doc.toString();
              this.cachedDialectId = dialectId;
              this.cachedDatabaseType = props.databaseType;
              this.cachedWindows = [];
            }

            const sql = this.cachedSql;
            const shouldPrewarmFullDocument = !boundedAnalysisEnabled() && this.cachedWindows.length === 0 && this.prewarmedDoc !== doc && sql.length <= MAX_FULL_DOCUMENT_SQL_SEMANTIC_HIGHLIGHT_LENGTH;
            const windows: Array<{
              from: number;
              to: number;
              spans: Array<{ start: number; end: number }>;
            }> = [];
            const pendingWindows: Array<{ from: number; to: number }> = [];
            const rangesToHighlight = shouldPrewarmFullDocument ? [{ from: 0, to: sql.length }] : currentView.visibleRanges;
            for (const visibleRange of rangesToHighlight) {
              const cached = this.cachedWindows.find((candidate) => candidate.from <= visibleRange.from && candidate.to >= visibleRange.to);
              if (cached) {
                if (!windows.includes(cached)) windows.push(cached);
                continue;
              }

              const next = expandToSqlStatementWindow(sql, visibleRange.from, visibleRange.to, dialectId);
              const cachedWindow = this.cachedWindows.find((candidate) => candidate.from <= next.from && candidate.to >= next.to);
              if (cachedWindow) {
                if (!windows.includes(cachedWindow)) windows.push(cachedWindow);
                continue;
              }

              const previous = pendingWindows[pendingWindows.length - 1];
              if (previous && next.from <= previous.to) previous.to = Math.max(previous.to, next.to);
              else pendingWindows.push({ ...next });
            }

            if (pendingWindows.length > 0) {
              const requestedTo = Math.max(...pendingWindows.map((window) => window.to));
              const tree = boundedAnalysisEnabled() ? (syntaxTreeAvailable(currentView.state, requestedTo) ? syntaxTree(currentView.state) : null) : ensureSyntaxTree(currentView.state, requestedTo, requestedTo === sql.length ? 250 : 25);
              if (!tree) {
                // The Lezer parse has not reached the pending windows yet (long
                // documents). Keep the decorations that are still valid and let
                // the deferred refresh rebuild them once parsing catches up —
                // returning an empty set here wiped table-name colors after
                // scrolling stopped or when a freshly mounted editor (tab
                // switch) had no later viewport change to trigger a rebuild.
                this.scheduleRefresh(currentView);
                return this.decorations;
              }
              if (shouldPrewarmFullDocument) this.prewarmedDoc = doc;
              for (const window of pendingWindows) {
                const entry = {
                  ...window,
                  spans: sqlSemanticTableNameSpansForSyntaxTree(sql, window, tree, {
                    databaseType: props.databaseType,
                    dialect: sqlBehaviorDialect(),
                  }),
                };
                this.cachedWindows.push(entry);
                windows.push(entry);
              }
              if (this.cachedWindows.length > MAX_SQL_SEMANTIC_HIGHLIGHT_WINDOWS) {
                this.cachedWindows.splice(0, this.cachedWindows.length - MAX_SQL_SEMANTIC_HIGHLIGHT_WINDOWS);
              }
            }

            const ranges = windows.flatMap((window) => window.spans);
            return Decoration.set(
              ranges.map((range) =>
                Decoration.mark({
                  class: "cm-sql-table-name",
                  attributes: {
                    "data-sql-token": "table",
                  },
                }).range(range.start, range.end),
              ),
              true,
            );
          }
        },
        { decorations: (value) => value.decorations },
      ),
      sqlSemanticHighlightTheme(EditorView),
      shellLineCommentTheme(EditorView),
    ];
  };

  function createViewDecorations() {
    const currentStatementFrameExtension = currentStatementFrameLayer(
      { layer, RectangleMarker },
      (view) => {
        if (!settingsStore.editorSettings.showCurrentStatementFrame) return null;
        if (view.state.selection.ranges.some((range) => !range.empty)) return null;
        const cursorPos = view.state.selection.main.head;
        const boundaries = statementBoundariesForState(view.state);
        if (!boundaries.fresh && boundaries.frameRange && cursorPos >= boundaries.frameRange.from && cursorPos <= boundaries.frameRange.to) {
          // Typing in progress: reuse the ChangeSet-shifted range instead of
          // re-parsing the whole document. The debounced refresh rebuilds and
          // repaints the exact frame once typing pauses.
          return { from: boundaries.frameRange.from, to: currentStatementFrameTo(view, { from: boundaries.frameRange.from, to: boundaries.frameRange.to, sql: "" }) };
        }
        if (boundedAnalysisEnabled() && !boundaries.fresh) return null;
        let range = currentExecutableStatementRange(view);
        if (!range) {
          const cursorLine = view.state.doc.lineAt(cursorPos);
          cache.value = executableStatementRangeCacheForDoc(cache.value, view.state.doc, queryEditorStatementDatabaseType(props.databaseType, props.mongoQueryLanguage), sqlStatementParameterOptions());
          // Find ranges that overlap the cursor line, then expand to include
          // adjacent ranges (handles parser fragments from edge cases like
          // ultra-long comments splitting a statement).
          let mergedFrom = cursorLine.from;
          let mergedTo = cursorLine.from;
          let changed = true;
          while (changed) {
            changed = false;
            for (const cachedRange of cache.value.ranges) {
              // Only merge ranges that overlap the cursor line or are adjacent
              // to the current merged region
              if (cachedRange.from <= mergedTo && cachedRange.to >= mergedFrom) {
                const newFrom = Math.min(mergedFrom, cachedRange.from);
                const newTo = Math.max(mergedTo, cachedRange.to);
                if (newFrom !== mergedFrom || newTo !== mergedTo) {
                  mergedFrom = newFrom;
                  mergedTo = newTo;
                  changed = true;
                }
              }
            }
          }
          if (mergedTo > mergedFrom) {
            range = { from: mergedFrom, to: mergedTo, sql: view.state.doc.sliceString(mergedFrom, mergedTo) };
          }
        }
        if (boundaries) boundaries.frameRange = range ? { from: range.from, to: range.to } : null;
        if (!range) return null;
        return { from: range.from, to: currentStatementFrameTo(view, range) };
      },
      {
        shouldRefresh(update) {
          const refreshEffect = codeMirrorRuntime.statementBoundariesRefreshEffect;
          return !!refreshEffect && update.transactions.some((transaction) => transaction.effects.some((effect) => effect.is(refreshEffect)));
        },
      },
    );

    function currentStatementFrameTo(view: import("@codemirror/view").EditorView, range: SqlTextRange): number {
      return currentStatementFrameRangeTo(view.state.doc, range);
    }

    const activeLineHighlighter = ViewPlugin.fromClass(
      class {
        decorations: import("@codemirror/view").DecorationSet;
        constructor(view: import("@codemirror/view").EditorView) {
          this.decorations = this.getDeco(view);
        }
        update(update: import("@codemirror/view").ViewUpdate) {
          if (update.docChanged || update.selectionSet) this.decorations = this.getDeco(update.view);
        }
        getDeco(view: import("@codemirror/view").EditorView) {
          if (!view.state.selection.main.empty) return Decoration.none;
          let lastLineStart = -1;
          const deco: any[] = [];
          for (const r of view.state.selection.ranges) {
            if (!r.empty) continue;
            const line = view.lineBlockAt(r.head);
            if (line.from > lastLineStart) {
              deco.push(Decoration.line({ class: "cm-activeLine" }).range(line.from));
              lastLineStart = line.from;
            }
          }
          return Decoration.set(deco);
        }
      },
      { decorations: (v) => v.decorations },
    );
    return { currentStatementFrameExtension, activeLineHighlighter };
  }
  return {
    createViewDecorations,
    buildPreviewRangeExtension: codeMirrorRuntime.buildPreviewRangeExtension,
    buildResultSourceRangeExtension: codeMirrorRuntime.buildResultSourceRangeExtension,
    buildSqlSignatureExtension: codeMirrorRuntime.buildSqlSignatureExtension,
    buildSqlLanguageExtension: codeMirrorRuntime.buildSqlLanguageExtension,
    buildSqlSemanticHighlightExtension: codeMirrorRuntime.buildSqlSemanticHighlightExtension,
    buildSqlCompletionExtension: codeMirrorRuntime.buildSqlCompletionExtension,
    buildSqlDiagnosticExtension: codeMirrorRuntime.buildSqlDiagnosticExtension,
  };
}