A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
Upgrade codemirror-sql (#10350)
Myles Scolnick21cba77855db
diff --git a/frontend/package.json b/frontend/package.jsonindex 8e8d7ecbf9..2742b347a7 100644--- a/frontend/package.json+++ b/frontend/package.json@@ -57,7 +57,7 @@"@marimo-team/codemirror-ai": "^0.3.7","@marimo-team/codemirror-languageserver": "^1.16.12","@marimo-team/codemirror-mcp": "^0.1.7",- "@marimo-team/codemirror-sql": "^0.2.8",+ "@marimo-team/codemirror-sql": "^0.3.0","@marimo-team/llm-info": "workspace:*","@marimo-team/marimo-api": "workspace:*","@marimo-team/react-slotz": "^0.2.0",diff --git a/frontend/src/core/codemirror/language/__tests__/sql.test.ts b/frontend/src/core/codemirror/language/__tests__/sql.test.tsindex be65c20d9f..387ce4a643 100644--- a/frontend/src/core/codemirror/language/__tests__/sql.test.ts+++ b/frontend/src/core/codemirror/language/__tests__/sql.test.ts@@ -1,13 +1,13 @@/* Copyright 2026 Marimo. All rights reserved. */-import type {- CompletionContext,- CompletionResult,-} from "@codemirror/autocomplete";-import { PostgreSQL } from "@codemirror/lang-sql";+import { CompletionContext } from "@codemirror/autocomplete";+import type { CompletionSource } from "@codemirror/autocomplete";+import { PostgreSQL, sql } from "@codemirror/lang-sql";+import { forEachDiagnostic, forceLinting } from "@codemirror/lint";import { EditorState, type Extension } from "@codemirror/state";+import { EditorView } from "@codemirror/view";import { DuckDBDialect } from "@marimo-team/codemirror-sql/dialects";-import { afterEach, beforeEach, describe, expect, it } from "vitest";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";import type { CellId } from "@/core/cells/ids";import type {CompletionConfig,@@ -20,6 +20,7 @@ import {setLatestEngineSelected,} from "@/core/datasets/data-source-connections";import { type ConnectionName, DUCKDB_ENGINE } from "@/core/datasets/engines";+import { ValidateSQL } from "@/core/datasets/request-registry";import { datasetsAtom } from "@/core/datasets/state";import type { DatasetsState } from "@/core/datasets/types";import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";@@ -27,10 +28,11 @@ import { store } from "@/core/state/jotai";import type { PlaceholderType } from "../../config/types";import { TestSQLCompletionStore } from "../languages/sql/completion-store";import {+ exportedForTesting,SQLLanguageAdapter,type SQLLanguageAdapterMetadata,} from "../languages/sql/sql";-import { languageMetadataField } from "../metadata";+import { languageMetadataField, updateLanguageMetadata } from "../metadata";const adapter = new SQLLanguageAdapter();@@ -634,6 +636,389 @@ _df = mo.sql(});});+describe("SQL analysis features", () => {+ const metadata: SQLLanguageAdapterMetadata = {+ dataframeName: "_df",+ quotePrefix: "f",+ commentLines: [],+ showOutput: true,+ engine: TEST_ENGINE,+ };++ const createConnection = (+ columns: string[],+ includeDefaultSchema = true,+ ): DataSourceConnection => ({+ name: TEST_ENGINE,+ dialect: "postgres",+ display_name: "PostgreSQL",+ source: "postgres",+ default_database: "test_db",+ default_schema: includeDefaultSchema ? "public" : undefined,+ databases: [+ {+ name: "test_db",+ dialect: "postgres",+ schemas: [+ {+ name: "public",+ tables: [+ {+ name: "users",+ source: "postgres",+ source_type: "local",+ type: "table",+ num_columns: columns.length,+ num_rows: 0,+ variable_name: null,+ columns: columns.map((name) => ({+ name,+ external_type: "string",+ type: "string",+ sample_values: [],+ })),+ },+ ],+ },+ ],+ },+ ],+ });++ const createCompletionContext = (doc: string, pos: number) => {+ const state = EditorState.create({+ doc,+ extensions: [languageMetadataField.init(() => metadata)],+ });+ const view = new EditorView({ state });+ return {+ context: new CompletionContext(view.state, pos, true, view),+ view,+ };+ };++ const getLabels = async (+ source: CompletionSource,+ context: CompletionContext,+ ) => {+ const result = await source(context);+ return result?.options.map((option) => option.label) ?? [];+ };++ beforeEach(() => {+ store.set(datasetsAtom, { tables: [] } as unknown as DatasetsState);+ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map([+ [TEST_ENGINE, createConnection(["id", "name"])],+ ]),+ latestEngineSelected: TEST_ENGINE,+ });+ });++ it("resolves alias completions from the latest connection schema", async () => {+ const analysis = exportedForTesting.createSQLAnalysis();+ const doc = "SELECT u. FROM users u";+ const { context, view } = createCompletionContext(doc, "SELECT u.".length);++ expect(await getLabels(analysis.aliasCompletionSource, context)).toEqual(+ expect.arrayContaining(["id", "name"]),+ );++ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map([+ [TEST_ENGINE, createConnection(["id", "name", "email"])],+ ]),+ latestEngineSelected: TEST_ENGINE,+ });++ expect(await getLabels(analysis.aliasCompletionSource, context)).toContain(+ "email",+ );+ view.destroy();+ });++ it("resolves aliases when the only schema is implicit", async () => {+ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map([+ [TEST_ENGINE, createConnection(["id", "name"], false)],+ ]),+ latestEngineSelected: TEST_ENGINE,+ });+ const analysis = exportedForTesting.createSQLAnalysis();+ const doc = "SELECT u. FROM users u";+ const { context, view } = createCompletionContext(doc, "SELECT u.".length);++ expect(await getLabels(analysis.aliasCompletionSource, context)).toEqual(+ expect.arrayContaining(["id", "name"]),+ );+ view.destroy();+ });++ it("preserves top-level namespaces when promoting default-schema tables", () => {+ const connection = createConnection(["id"]);+ const database = connection.databases[0]!;+ const publicSchema = database.schemas[0]!;+ const usersTable = publicSchema.tables[0]!;+ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map([+ [+ TEST_ENGINE,+ {+ ...connection,+ databases: [+ {+ ...database,+ schemas: [+ {+ ...publicSchema,+ tables: [+ ...publicSchema.tables,+ { ...usersTable, name: "analytics" },+ { ...usersTable, name: "test_db" },+ ],+ },+ {+ name: "analytics",+ tables: [{ ...usersTable, name: "events" }],+ },+ ],+ },+ ],+ },+ ],+ ]),+ latestEngineSelected: TEST_ENGINE,+ });+ const state = EditorState.create({+ extensions: [languageMetadataField.init(() => metadata)],+ });+ const view = new EditorView({ state });++ expect(exportedForTesting.getSchema(view)).toMatchObject({+ analytics: {+ self: { label: "analytics", type: "schema" },+ children: {+ events: { self: { label: "events", type: "table" } },+ },+ },+ public: {+ children: {+ analytics: { self: { label: "analytics", type: "table" } },+ test_db: { self: { label: "test_db", type: "table" } },+ },+ },+ test_db: {+ self: { label: "test_db", type: "database" },+ },+ });+ view.destroy();+ });++ it("resolves a table literally named self", async () => {+ store.set(datasetsAtom, {+ tables: [+ {+ name: "self",+ columns: [{ name: "value", type: "string" }],+ },+ ],+ } as DatasetsState);+ const analysis = exportedForTesting.createSQLAnalysis();+ const doc = "SELECT s. FROM self s";+ const { context, view } = createCompletionContext(doc, "SELECT s.".length);++ expect(await getLabels(analysis.aliasCompletionSource, context)).toContain(+ "value",+ );+ view.destroy();+ });++ it("completes declared CTE columns", async () => {+ const analysis = exportedForTesting.createSQLAnalysis();+ const doc =+ "WITH active_users(user_id, user_email) AS (SELECT id, email FROM users) " ++ "SELECT active_users. FROM active_users";+ const pos = doc.indexOf("active_users.") + "active_users.".length;+ const { context, view } = createCompletionContext(doc, pos);++ expect(await getLabels(analysis.cteCompletionSource, context)).toEqual(+ expect.arrayContaining(["user_id", "user_email"]),+ );+ view.destroy();+ });++ it("completes columns from tables in the current statement", async () => {+ const analysis = exportedForTesting.createSQLAnalysis();+ const doc = "SELECT na FROM users";+ const { context, view } = createCompletionContext(doc, "SELECT na".length);++ expect(await getLabels(analysis.columnCompletionSource, context)).toContain(+ "name",+ );+ view.destroy();+ });++ it("reports semantic diagnostics as warnings", async () => {+ const adapter = new SQLLanguageAdapter();+ const extensions = adapter.getExtension(+ {} as CellId,+ {} as CompletionConfig,+ {} as HotkeyProvider,+ {} as PlaceholderType,+ {+ diagnostics: { sql_linter: true },+ } as LSPConfig & { diagnostics: DiagnosticsConfig },+ );+ const state = EditorState.create({+ doc: "SELECT missing FROM users",+ extensions: [languageMetadataField.init(() => metadata), ...extensions],+ });+ const view = new EditorView({ state });++ forceLinting(view);+ await vi.waitFor(() => {+ const diagnostics: Array<{ message: string; severity: string }> = [];+ forEachDiagnostic(view.state, (diagnostic) => {+ diagnostics.push(diagnostic);+ });+ expect(diagnostics).toContainEqual(+ expect.objectContaining({+ message: "Column 'missing' not found in table 'users'",+ severity: "warning",+ }),+ );+ });+ view.destroy();+ });++ it("does not report unknown tables", async () => {+ const adapter = new SQLLanguageAdapter();+ const extensions = adapter.getExtension(+ {} as CellId,+ {} as CompletionConfig,+ {} as HotkeyProvider,+ {} as PlaceholderType,+ {+ diagnostics: { sql_linter: true },+ } as LSPConfig & { diagnostics: DiagnosticsConfig },+ );+ const state = EditorState.create({+ doc: "SELECT missing FROM users; SELECT * FROM unknown_table",+ extensions: [languageMetadataField.init(() => metadata), ...extensions],+ });+ const view = new EditorView({ state });++ forceLinting(view);+ await vi.waitFor(() => {+ const diagnostics: string[] = [];+ forEachDiagnostic(view.state, (diagnostic) => {+ diagnostics.push(diagnostic.message);+ });+ expect(diagnostics).toEqual([+ "Column 'missing' not found in table 'users'",+ ]);+ });+ view.destroy();+ });++ it("invalidates analysis caches when the engine changes", async () => {+ const mssqlEngine = "mssql_engine" as ConnectionName;+ const postgresEngine = "postgres_engine" as ConnectionName;+ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map([+ [+ mssqlEngine,+ {+ ...createConnection([]),+ name: mssqlEngine,+ dialect: "mssql",+ },+ ],+ [+ postgresEngine,+ {+ ...createConnection([]),+ name: postgresEngine,+ dialect: "postgres",+ },+ ],+ ]),+ latestEngineSelected: mssqlEngine,+ });+ const analysis = exportedForTesting.createSQLAnalysis();+ const state = EditorState.create({+ doc: "SELECT TOP 1 * FROM users",+ extensions: [+ languageMetadataField.init(() => ({+ ...metadata,+ engine: mssqlEngine,+ })),+ ],+ });+ const view = new EditorView({ state });++ const before = await analysis.structureAnalyzer.analyzeDocument(view.state);+ expect(before[0]?.isValid).toBe(true);++ view.dispatch({+ effects: updateLanguageMetadata.of({ engine: postgresEngine }),+ });++ const after = await analysis.structureAnalyzer.analyzeDocument(view.state);+ expect(after[0]?.isValid).toBe(false);+ view.destroy();+ });+});++describe("CustomSqlParser", () => {+ afterEach(() => {+ vi.useRealTimers();+ vi.restoreAllMocks();+ });++ it("uses backend DuckDB validation", async () => {+ vi.useFakeTimers();+ const error = {+ message: "Backend syntax error",+ line: 1,+ column: 1,+ severity: "error" as const,+ };+ const request = vi.spyOn(ValidateSQL, "request").mockResolvedValue({+ error: null,+ parse_result: { success: false, errors: [error] },+ request_id: "request-id",+ validate_result: null,+ });+ const state = EditorState.create({+ doc: "SELECT",+ extensions: [+ languageMetadataField.init(() => ({+ dataframeName: "_df",+ quotePrefix: "f",+ commentLines: [],+ showOutput: true,+ engine: DUCKDB_ENGINE,+ })),+ ],+ });+ const parser = new exportedForTesting.CustomSqlParser();+ parser.setFocusState(true);++ const result = parser.validateSql("SELECT", { state });+ await vi.runAllTimersAsync();++ await expect(result).resolves.toEqual([error]);+ expect(request).toHaveBeenCalledWith(+ expect.objectContaining({+ engine: DUCKDB_ENGINE,+ onlyParse: true,+ query: "SELECT",+ }),+ );+ });+});+describe("tablesCompletionSource", () => {const mockStore = store;const completionStore = new TestSQLCompletionStore();@@ -1523,6 +1908,7 @@ describe("tablesCompletionSource", () => {const completionSource = completionStore.getCompletionSource(TEST_ENGINE);expect(completionSource?.defaultTable).toBe("users");+ expect(completionSource?.defaultSchema).toBe("public");expect(completionSource?.dialect).toBe(PostgreSQL);});@@ -1654,17 +2040,7 @@ describe("tablesCompletionSource", () => {`);});- it("should return local tables", () => {- const testDatasets = [- {- name: "dataset1",- columns: [- { name: "col1", type: "number" },- { name: "col2", type: "string" },- ],- },- ];-+ describe("completion sources", () => {describe("SQL Completions", () => {const completionStore = new TestSQLCompletionStore();@@ -1695,54 +2071,57 @@ describe("tablesCompletionSource", () => {return EditorState.create({doc,- extensions: [languageMetadataField.init(() => defaultMetadata)],+ extensions: [+ languageMetadataField.init(() => defaultMetadata),+ sql({ dialect: PostgreSQL }),+ ],});};const createCompletionContext = (state: EditorState,pos: number,- matchText?: string,- matchFrom?: number,): CompletionContext => {- return {- pos,- explicit: false,- matchBefore: matchText- ? () => ({- from: matchFrom || pos - matchText.length,- to: pos,- text: matchText,- })- : () => null,- state,- aborted: false,- tokenBefore: () => null,- } as unknown as CompletionContext;+ return new CompletionContext(state, pos, false);};- const getCompletion = (extensions: Extension[]) => {- // oxlint-disable-next-line typescript/no-explicit-any- const ext = extensions.find((ext) => (ext as any).facet === undefined);- // oxlint-disable-next-line typescript/no-explicit-any- return (ext as any)?.value?.override?.[0];+ const getCompletionSources = (+ extensions: readonly Extension[],+ ): readonly CompletionSource[] | undefined => {+ for (const extension of extensions) {+ if (Array.isArray(extension)) {+ const sources = getCompletionSources(extension);+ if (sources) {+ return sources;+ }+ continue;+ }++ const config = extension as {+ value?: { override?: readonly CompletionSource[] };+ };+ if (config.value?.override) {+ return config.value.override;+ }+ }+ return undefined;};describe("tablesCompletionSource", () => {- it("should return null when no connection exists", () => {+ it("should return null when no connection exists", async () => {const state = createEditorState("SELECT * FROM ");const ctx = createCompletionContext(state, 14);const adapter = new SQLLanguageAdapter();const extensions = adapter.getExtension(...TEST_EXTENSION_ARGS);- const completion = getCompletion(extensions);+ const completion = getCompletionSources(extensions)?.[0];expect(completion).toBeDefined();- const result = completion!(ctx);+ const result = await completion!(ctx);expect(result).toBeNull();});- it("should provide table completions when connection exists", () => {+ it("should provide table completions when connection exists", async () => {const mockConnection: DataSourceConnection = {name: TEST_ENGINE,dialect: "postgres",@@ -1794,19 +2173,19 @@ describe("tablesCompletionSource", () => {const state = createEditorState("SELECT * FROM u", {engine: TEST_ENGINE,});- const ctx = createCompletionContext(state, 15, "u", 14);+ const ctx = createCompletionContext(state, 15);const adapter = new SQLLanguageAdapter();const extensions = adapter.getExtension(...TEST_EXTENSION_ARGS);- const completion = getCompletion(extensions);+ const completion = getCompletionSources(extensions)?.[0];expect(completion).toBeDefined();- const result = completion!(ctx);+ const result = await completion!(ctx);expect(result).toBeDefined();expect(result?.options.length).toBeGreaterThan(0);});- it("should include local datasets in completions", () => {+ it("should include local datasets in completions", async () => {const mockConnection: DataSourceConnection = {name: TEST_ENGINE,dialect: "duckdb",@@ -1825,14 +2204,14 @@ describe("tablesCompletionSource", () => {const state = createEditorState("SELECT * FROM d", {engine: TEST_ENGINE,});- const ctx = createCompletionContext(state, 15, "d", 14);+ const ctx = createCompletionContext(state, 15);const adapter = new SQLLanguageAdapter();const extensions = adapter.getExtension(...TEST_EXTENSION_ARGS);- const completion = getCompletion(extensions);+ const completion = getCompletionSources(extensions)?.[0];expect(completion).toBeDefined();- const result: CompletionResult = completion!(ctx);+ const result = await completion!(ctx);expect(result).toBeDefined();expect(result?.options.some((opt) => opt.label === "dataset1")).toBe(true,@@ -1841,7 +2220,7 @@ describe("tablesCompletionSource", () => {});describe("customKeywordCompletionSource", () => {- it("should provide SQL keyword completions", () => {+ it("should provide SQL keyword completions", async () => {const mockConnection: DataSourceConnection = {name: TEST_ENGINE,dialect: "postgres",@@ -1858,21 +2237,21 @@ describe("tablesCompletionSource", () => {const state = createEditorState("SEL", {engine: TEST_ENGINE,});- const ctx = createCompletionContext(state, 3, "SEL", 0);+ const ctx = createCompletionContext(state, 3);const adapter = new SQLLanguageAdapter();const extensions = adapter.getExtension(...TEST_EXTENSION_ARGS);- const completion = getCompletion(extensions);+ const completion = getCompletionSources(extensions)?.[2];expect(completion).toBeDefined();- const result: CompletionResult = completion!(ctx);+ const result = await completion!(ctx);expect(result).toBeDefined();expect(result?.options.some((opt) => opt.label === "SELECT")).toBe(true,);});- it("should not provide keyword completions after dot", () => {+ it("should not provide keyword completions after dot", async () => {const mockConnection: DataSourceConnection = {name: TEST_ENGINE,dialect: "postgres",@@ -1889,14 +2268,14 @@ describe("tablesCompletionSource", () => {const state = createEditorState("SELECT users.n", {engine: TEST_ENGINE,});- const ctx = createCompletionContext(state, 14, ".n", 12);+ const ctx = createCompletionContext(state, 14);const adapter = new SQLLanguageAdapter();const extensions = adapter.getExtension(...TEST_EXTENSION_ARGS);- const completion = getCompletion(extensions);+ const completion = getCompletionSources(extensions)?.[2];expect(completion).toBeDefined();- const result = completion!(ctx);+ const result = await completion!(ctx);expect(result).toBeNull();});@@ -1925,13 +2304,16 @@ describe("tablesCompletionSource", () => {it("should be included in extension overrides", () => {const adapter = new SQLLanguageAdapter();const extensions = adapter.getExtension(...TEST_EXTENSION_ARGS);- const completion = getCompletion(extensions);+ const completion = getCompletionSources(extensions);expect(completion).toBeDefined();- expect(completion).toHaveLength(3); // tablesCompletionSource, variableCompletionSource, customKeywordCompletionSource+ expect(completion).toHaveLength(6);});});});+ });++ it("should return local tables", () => {mockStore.set(datasetsAtom, { tables: testDatasets } as DatasetsState);const mockConnection: DataSourceConnection = {diff --git a/frontend/src/core/codemirror/language/languages/sql/completion-store.ts b/frontend/src/core/codemirror/language/languages/sql/completion-store.tsindex 930e89e63c..5846c9d0fb 100644--- a/frontend/src/core/codemirror/language/languages/sql/completion-store.ts+++ b/frontend/src/core/codemirror/language/languages/sql/completion-store.ts@@ -109,7 +109,11 @@ class SQLCompletionStore {return {shouldAddLocalTables: true,schema: builder.build(),- defaultSchema: default_schema ?? undefined,+ defaultSchema:+ default_schema ??+ (defaultDb?.schemas.length === 1+ ? defaultDb.schemas[0]?.name+ : undefined),};}diff --git a/frontend/src/core/codemirror/language/languages/sql/sql.ts b/frontend/src/core/codemirror/language/languages/sql/sql.tsindex 3a35405d2e..b420f320b6 100644--- a/frontend/src/core/codemirror/language/languages/sql/sql.ts+++ b/frontend/src/core/codemirror/language/languages/sql/sql.ts@@ -12,12 +12,17 @@ import {type ViewUpdate,} from "@codemirror/view";import {+ aliasColumnCompletionSource,+ createCteCompletionSource,defaultSqlHoverTheme,NodeSqlParser,type NodeSqlParserResult,+ QueryContextAnalyzer,type SupportedDialects as ParserDialects,type SqlParseError,sqlExtension,+ SqlStructureAnalyzer,+ unqualifiedColumnCompletionSource,} from "@marimo-team/codemirror-sql";import { DuckDBDialect } from "@marimo-team/codemirror-sql/dialects";import { type SQLMetadata, SQLParser } from "@marimo-team/smart-cells";@@ -142,6 +147,7 @@ export class SQLLanguageAdapter implements LanguageAdapter<SQLLanguageAdapterMet_placeholderType: PlaceholderType,lspConfig: LSPConfig & { diagnostics: DiagnosticsConfig },): Extension[] {+ const analysis = createSQLAnalysis();const extensions = [// This can be updated with a dispatch effectsqlConfigCompartment.of(sql({ dialect: DEFAULT_DIALECT })),@@ -167,6 +173,10 @@ export class SQLLanguageAdapter implements LanguageAdapter<SQLLanguageAdapterMetvariableCompletionSource,// Completions for dialect keywordscustomKeywordCompletionSource(),+ // Completions based on the current query+ analysis.cteCompletionSource,+ analysis.aliasCompletionSource,+ analysis.columnCompletionSource,],}),];@@ -185,10 +195,23 @@ export class SQLLanguageAdapter implements LanguageAdapter<SQLLanguageAdapterMetextensions.push(sqlExtension({+ schema: getSchema,enableLinting: true,linterConfig: {delay: 250, // Delay before running validationparser: parser,+ // CustomSqlParser performs backend DuckDB validation in validateSql.+ perStatement: false,+ },+ enableSemanticLinting: true,+ semanticLinterConfig: {+ parser: analysis.parser,+ structureAnalyzer: analysis.structureAnalyzer,+ severity: {+ unknownTable: "off",+ unknownColumn: "warning",+ ambiguousColumn: "warning",+ },},enableGutterMarkers: true,gutterConfig: {@@ -198,14 +221,21 @@ export class SQLLanguageAdapter implements LanguageAdapter<SQLLanguageAdapterMetparser: parser,},hoverConfig: {- schema: getSchema, // Use the same schema as autocompletehoverTime: 300, // 300ms hover delayenableKeywords: true, // Show keyword informationenableTables: true, // Show table informationenableColumns: true, // Show column information- parser: parser,+ parser: analysis.parser,+ contextAnalyzer: analysis.contextAnalyzer,theme: defaultSqlHoverTheme(theme),},+ enableNavigation: true,+ navigationConfig: {+ contextAnalyzer: analysis.contextAnalyzer,+ keymap: false,+ parser: analysis.parser,+ structureAnalyzer: analysis.structureAnalyzer,+ },}),EditorView.updateListener.of((update) => {if (update.focusChanged) {@@ -223,6 +253,123 @@ export class SQLLanguageAdapter implements LanguageAdapter<SQLLanguageAdapterMet}}+function createSQLAnalysis() {+ const parser = new NodeSqlParser({+ getParserOptions: (state: EditorState) => {+ return {+ database: getAnalysisDialect(state),+ };+ },+ });+ const contextAnalyzer = new DialectAwareQueryContextAnalyzer(parser);+ const structureAnalyzer = new DialectAwareSqlStructureAnalyzer(parser);++ return {+ parser,+ contextAnalyzer,+ structureAnalyzer,+ cteCompletionSource: createCteCompletionSource({+ parser,+ contextAnalyzer,+ structureAnalyzer,+ }),+ aliasCompletionSource: aliasColumnCompletionSource({+ schema: getSchema,+ parser,+ contextAnalyzer,+ }),+ columnCompletionSource: unqualifiedColumnCompletionSource({+ schema: getSchema,+ parser,+ contextAnalyzer,+ }),+ };+}++function getAnalysisDialect(state: EditorState): ParserDialects {+ return guessParserDialect(state) ?? DEFAULT_PARSER_DIALECT;+}++class DialectAwareQueryContextAnalyzer extends QueryContextAnalyzer {+ private readonly analyzers = new Map<ParserDialects, QueryContextAnalyzer>();+ private readonly analysisParser: NodeSqlParser;++ constructor(analysisParser: NodeSqlParser) {+ super(analysisParser);+ this.analysisParser = analysisParser;+ }++ override getContext(+ sql: string,+ opts: { state: EditorState },+ ): ReturnType<QueryContextAnalyzer["getContext"]> {+ return this.getAnalyzer(opts.state).getContext(sql, opts);+ }++ override clearCache(): void {+ for (const analyzer of this.analyzers.values()) {+ analyzer.clearCache();+ }+ }++ private getAnalyzer(state: EditorState): QueryContextAnalyzer {+ const dialect = getAnalysisDialect(state);+ let analyzer = this.analyzers.get(dialect);+ if (!analyzer) {+ analyzer = new QueryContextAnalyzer(this.analysisParser);+ this.analyzers.set(dialect, analyzer);+ }+ return analyzer;+ }+}++class DialectAwareSqlStructureAnalyzer extends SqlStructureAnalyzer {+ private readonly analyzers = new Map<ParserDialects, SqlStructureAnalyzer>();+ private readonly analysisParser: NodeSqlParser;++ constructor(analysisParser: NodeSqlParser) {+ super(analysisParser);+ this.analysisParser = analysisParser;+ }++ override analyzeDocument(+ state: EditorState,+ ): ReturnType<SqlStructureAnalyzer["analyzeDocument"]> {+ return this.getAnalyzer(state).analyzeDocument(state);+ }++ override getStatementAtPosition(+ state: EditorState,+ position: number,+ ): ReturnType<SqlStructureAnalyzer["getStatementAtPosition"]> {+ return this.getAnalyzer(state).getStatementAtPosition(state, position);+ }++ override getStatementsInRange(+ state: EditorState,+ from: number,+ to: number,+ ): ReturnType<SqlStructureAnalyzer["getStatementsInRange"]> {+ return this.getAnalyzer(state).getStatementsInRange(state, from, to);+ }++ override clearCache(): void {+ for (const analyzer of this.analyzers.values()) {+ analyzer.clearCache();+ }+ }++ private getAnalyzer(state: EditorState): SqlStructureAnalyzer {+ const dialect = getAnalysisDialect(state);+ let analyzer = this.analyzers.get(dialect);+ if (!analyzer) {+ analyzer = new SqlStructureAnalyzer(this.analysisParser);+ this.analyzers.set(dialect, analyzer);+ }+ return analyzer;+ }+}+class CustomSqlParser extends NodeSqlParser {private validationTimeout: number | null = null;private readonly VALIDATION_DELAY_MS = 300; // Wait 300ms after user stops typing@@ -344,7 +491,61 @@ function getSchema(view: EditorView): SQLNamespace {return {};}- return config.schema;+ const schema = config.schema;+ if (!isNamespaceMap(schema)) {+ return schema;+ }++ const defaultSchema = config.defaultSchema;+ const defaultSchemaNamespace = defaultSchema+ ? schema[defaultSchema]+ : undefined;++ // The completion schema contains both default-schema and fully qualified+ // paths. Promote default-schema tables so unqualified references resolve to+ // one exact match instead of appearing ambiguous.+ if (+ defaultSchemaNamespace &&+ !Array.isArray(defaultSchemaNamespace) &&+ typeof defaultSchemaNamespace === "object" &&+ "children" in defaultSchemaNamespace &&+ isNamespaceMap(defaultSchemaNamespace.children)+ ) {+ return {+ ...schema,+ ...Object.fromEntries(+ Object.entries(defaultSchemaNamespace.children).filter(+ ([name]) => !Object.hasOwn(schema, name),+ ),+ ),+ };+ }++ return schema;+}++function isNamespaceMap(+ namespace: SQLNamespace,+): namespace is Record<string, SQLNamespace> {+ if (Array.isArray(namespace)) {+ return false;+ }++ if (!("self" in namespace) || !("children" in namespace)) {+ return true;+ }++ // A self/children wrapper stores a Completion in `self`. A table or schema+ // literally named "self" stores another namespace there.+ const self = namespace.self;+ const isSelfChildrenWrapper =+ typeof self === "object" &&+ self !== null &&+ !Array.isArray(self) &&+ "label" in self &&+ typeof self.label === "string";++ return !isSelfChildrenWrapper;}function guessParserDialect(state: EditorState): ParserDialects | null {@@ -529,3 +730,9 @@ async function validateSQL(}return result;}++export const exportedForTesting = {+ createSQLAnalysis,+ CustomSqlParser,+ getSchema,+};diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex bb25cc1472..cc2f0d87eb 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -146,8 +146,8 @@ importers:specifier: ^0.1.7version: 0.1.7(@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])(@modelcontextprotocol/[email protected])'@marimo-team/codemirror-sql':- specifier: ^0.2.8- version: 0.2.8(@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])+ specifier: ^0.3.0+ version: 0.3.0(@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])'@marimo-team/llm-info':specifier: workspace:*version: link:../packages/llm-info@@ -1699,8 +1699,8 @@ packages:'@codemirror/view': ^6'@modelcontextprotocol/sdk': ^1- '@marimo-team/[email protected]':- resolution: {integrity: sha512-OT9JsZz3Nfynm9wKTDbqnfQ2YYn5tclrKpN3npUr4JuuKvqT2Z9nCDGS4IH86prHboeR0vJy+2Q+8zK2LS03yA==}+ '@marimo-team/[email protected]':+ resolution: {integrity: sha512-cAEWKQ15akEc0i8Ax6D+WI3temUy6FpNkVnN1j2SvDSjHmK8BfwBZ6nzelQbrR+PBjw6M3TcZaygZL4a1HG/Qg==}peerDependencies:'@codemirror/autocomplete': ^6'@codemirror/lint': ^6@@ -7416,8 +7416,8 @@ packages:resolution: {integrity: sha512-J6l92tKHX6w8Jy5nO1Vuc01NoIiRGi/d6qBKVxh+IQ8Cr3b6HbVNfKiF8ZpFKufTwpwxMmce2W3iQZ861ZRyTg==}engines: {node: '>=18'}- resolution: {integrity: sha512-heyWv3lLjKHpcBDMUSR+R0DohRYZTYq+Ro3hJ4m9Ia8ccdKbL5UijIaWr2L4co+bmmFuvBVZ4v23QW2PqvBFAA==}+ resolution: {integrity: sha512-jVe6Z61gPcPjCElPZ6j8llB3wnqGcuQzefim1ERsqIakxnEy5JlzV7XKdO1KmacRG5TKwPc4vJTgSRQ0LfkbFw==}engines: {node: '>=8'}@@ -11241,13 +11241,13 @@ snapshots:'@codemirror/view': 6.43.6'@modelcontextprotocol/sdk': 1.17.2- '@marimo-team/[email protected](@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])':+ '@marimo-team/[email protected](@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])(@codemirror/[email protected])':dependencies:'@codemirror/autocomplete': 6.20.3'@codemirror/lint': 6.9.7'@codemirror/state': 6.7.1'@codemirror/view': 6.43.6- node-sql-parser: 5.3.13+ node-sql-parser: 5.4.0'@marimo-team/[email protected]([email protected])':dependencies:@@ -17901,7 +17901,7 @@ snapshots:dependencies:'@types/pegjs': 0.10.6big-integer: 1.6.52