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
fix(sql): validate named DuckDB connections (#10400)
Shahmir Varqha74987ba6f4af
diff --git a/frontend/src/core/codemirror/language/__tests__/sql.test.ts b/frontend/src/core/codemirror/language/__tests__/sql.test.tsindex 387ce4a643..78daea258b 100644--- a/frontend/src/core/codemirror/language/__tests__/sql.test.ts+++ b/frontend/src/core/codemirror/language/__tests__/sql.test.ts@@ -27,6 +27,7 @@ import type { HotkeyProvider } from "@/core/hotkeys/hotkeys";import { store } from "@/core/state/jotai";import type { PlaceholderType } from "../../config/types";import { TestSQLCompletionStore } from "../languages/sql/completion-store";+import * as sqlMode from "../languages/sql/sql-mode";import {exportedForTesting,SQLLanguageAdapter,@@ -971,13 +972,63 @@ describe("SQL analysis features", () => {});describe("CustomSqlParser", () => {+ beforeEach(() => {+ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map(),+ latestEngineSelected: DUCKDB_ENGINE,+ });+ });+afterEach(() => {vi.useRealTimers();vi.restoreAllMocks();+ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map(),+ latestEngineSelected: DUCKDB_ENGINE,+ });});+ const createNamedConnectionState = ({+ doc,+ engine,+ dialect,+ }: {+ doc: string;+ engine: ConnectionName;+ dialect: string;+ }) => {+ store.set(dataSourceConnectionsAtom, {+ connectionsMap: new Map([+ [+ engine,+ {+ name: engine,+ dialect,+ display_name: engine,+ source: dialect,+ databases: [],+ },+ ],+ ]),+ latestEngineSelected: engine,+ });+ return EditorState.create({+ doc,+ extensions: [+ languageMetadataField.init(() => ({+ dataframeName: "_df",+ quotePrefix: "f",+ commentLines: [],+ showOutput: true,+ engine,+ })),+ ],+ });+ };+it("uses backend DuckDB validation", async () => {vi.useFakeTimers();+ vi.spyOn(sqlMode, "getSQLMode").mockReturnValue("validate");const error = {message: "Backend syntax error",line: 1,@@ -1009,13 +1060,146 @@ describe("CustomSqlParser", () => {await vi.runAllTimersAsync();await expect(result).resolves.toEqual([error]);- expect(request).toHaveBeenCalledWith(- expect.objectContaining({- engine: DUCKDB_ENGINE,- onlyParse: true,- query: "SELECT",- }),- );+ // No connection is registered for the internal engine, so the dialect+ // falls back to DEFAULT_PARSER_DIALECT ("DuckDB").+ expect(request).toHaveBeenCalledWith({+ dialect: "DuckDB",+ engine: DUCKDB_ENGINE,+ onlyParse: false,+ query: "SELECT",+ });+ });++ it("resolves superseded validation requests instead of leaving them pending", async () => {+ vi.useFakeTimers();+ vi.spyOn(sqlMode, "getSQLMode").mockReturnValue("validate");+ const error = {+ message: "Backend syntax error",+ line: 1,+ column: 1,+ severity: "error" as const,+ };+ 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);++ // Simulate a rapid edit: a second validation call arrives before the+ // first call's internal debounce timer has fired. The first call should+ // resolve (with no errors) rather than hang forever.+ const first = parser.validateSql("SELECT 1", { state });+ await vi.advanceTimersByTimeAsync(100);+ const second = parser.validateSql("SELECT 2", { state });+ await vi.runAllTimersAsync();++ await expect(first).resolves.toEqual([]);+ await expect(second).resolves.toEqual([error]);+ });++ it("uses backend validation for a named DuckDB connection", async () => {+ vi.useFakeTimers();+ vi.spyOn(sqlMode, "getSQLMode").mockReturnValue("validate");+ const query =+ 'INSERT OR IGNORE INTO "rebalance-dates" (Timestamp) VALUES (CURRENT_TIMESTAMP);';+ const error = {+ message: "Named DuckDB backend result",+ 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 = createNamedConnectionState({+ doc: query,+ engine: "con" as ConnectionName,+ dialect: "duckdb",+ });+ const parser = new exportedForTesting.CustomSqlParser();+ parser.setFocusState(true);++ const result = parser.validateSql(query, { state });+ await vi.runAllTimersAsync();++ await expect(result).resolves.toEqual([error]);+ expect(request).toHaveBeenCalledWith({+ dialect: "DuckDB",+ engine: "con",+ onlyParse: true,+ query,+ });+ });++ it("skips client-side parsing for named DuckDB SQL", async () => {+ const query = "CHECKPOINT;";+ const state = createNamedConnectionState({+ doc: query,+ engine: "con" as ConnectionName,+ dialect: "duckdb",+ });+ const parser = new exportedForTesting.CustomSqlParser();++ await expect(parser.parse(query, { state })).resolves.toEqual({+ success: true,+ errors: [],+ });+ });++ it("preserves client-side parsing for non-DuckDB connections", async () => {+ const query = "SELECT TOP 1 * FROM users";+ const state = createNamedConnectionState({+ doc: query,+ engine: "postgres_con" as ConnectionName,+ dialect: "postgres",+ });+ const parser = new exportedForTesting.CustomSqlParser();++ await expect(parser.parse(query, { state })).resolves.toMatchObject({+ success: false,+ });+ });++ it("preserves client-side parsing for an unregistered connection", async () => {+ // No entry is registered in the data source connections store for this+ // engine, so its dialect cannot be resolved (unlike a known non-DuckDB+ // dialect, which resolves to a non-null, non-DuckDB value).+ const query = "SELECT TOP 1 * FROM users";+ const state = EditorState.create({+ doc: query,+ extensions: [+ languageMetadataField.init(() => ({+ dataframeName: "_df",+ quotePrefix: "f",+ commentLines: [],+ showOutput: true,+ engine: "unregistered_con" as ConnectionName,+ })),+ ],+ });+ const parser = new exportedForTesting.CustomSqlParser();++ await expect(parser.parse(query, { state })).resolves.toMatchObject({+ success: false,+ });});});diff --git a/frontend/src/core/codemirror/language/languages/sql/sql.ts b/frontend/src/core/codemirror/language/languages/sql/sql.tsindex b420f320b6..afbd23f624 100644--- a/frontend/src/core/codemirror/language/languages/sql/sql.ts+++ b/frontend/src/core/codemirror/language/languages/sql/sql.ts@@ -66,7 +66,7 @@ import { getSQLMode, type SQLMode } from "./sql-mode";import { isKnownDialect } from "./utils";const DEFAULT_DIALECT = DuckDBDialect;-const DEFAULT_PARSER_DIALECT = "DuckDB";+const DEFAULT_PARSER_DIALECT: ParserDialects = "DuckDB";// A compartment for the SQL config, so we can update the config of codemirrorconst sqlConfigCompartment = new Compartment();@@ -372,6 +372,8 @@ class DialectAwareSqlStructureAnalyzer extends SqlStructureAnalyzer {class CustomSqlParser extends NodeSqlParser {private validationTimeout: number | null = null;+ private pendingValidationResolve: ((errors: SqlParseError[]) => void) | null =+ null;private readonly VALIDATION_DELAY_MS = 300; // Wait 300ms after user stops typingprivate isFocused = false; // Only validate if the editor is focused@@ -379,37 +381,51 @@ class CustomSqlParser extends NodeSqlParser {this.isFocused = focused;}+ private resolvePendingValidation(errors: SqlParseError[]): void {+ this.pendingValidationResolve?.(errors);+ this.pendingValidationResolve = null;+ }+private async validateWithDelay(sql: string,- engine: string,+ engine: ConnectionName,dialect: ParserDialects | null,): Promise<SqlParseError[]> {- // Clear any existing delay call+ // Clear any existing delay call, resolving its promise so a superseded+ // request doesn't hang forever.if (this.validationTimeout) {window.clearTimeout(this.validationTimeout);+ this.resolvePendingValidation([]);}// Set up a new request to be called after the delayreturn new Promise((resolve) => {+ this.pendingValidationResolve = resolve;this.validationTimeout = window.setTimeout(async () => {+ this.validationTimeout = null;+// Only validate if the editor is still focusedif (!this.isFocused) {- resolve([]);+ this.resolvePendingValidation([]);return;}try {- const sqlMode = getSQLMode();+ // For validate mode, we run EXPLAIN queries on the engine, which can be+ // expensive for remote databases. So, we only run for internal engines.+ const sqlMode = INTERNAL_SQL_ENGINES.has(engine)+ ? getSQLMode()+ : "default";const result = await validateSQL(sql, engine, dialect, sqlMode);if (result.error) {Logger.error("Failed to validate SQL", { error: result.error });- resolve([]);+ this.resolvePendingValidation([]);return;}- resolve(result.parse_result?.errors ?? []);+ this.resolvePendingValidation(result.parse_result?.errors ?? []);} catch (error) {Logger.error("Failed to validate SQL", { error });- resolve([]);+ this.resolvePendingValidation([]);}}, this.VALIDATION_DELAY_MS);});@@ -420,19 +436,23 @@ class CustomSqlParser extends NodeSqlParser {opts: { state: EditorState },): Promise<SqlParseError[]> {const metadata = getSQLMetadata(opts.state);+ const dialect = connectionNameToParserDialect(metadata.engine);// Only validate if the editor is focusedif (!this.isFocused) {return [];}- // Only perform custom validation for DuckDB- if (!INTERNAL_SQL_ENGINES.has(metadata.engine)) {+ // Only perform custom validation for DuckDB as we have a custom validation endpoint for it.+ if (!isDuckDBConnection(metadata.engine, dialect)) {return super.validateSql(sql, opts);}- const dialect = guessParserDialect(opts.state);- return this.validateWithDelay(sql, metadata.engine, dialect);+ return this.validateWithDelay(+ sql,+ metadata.engine,+ dialect ?? DEFAULT_PARSER_DIALECT,+ );}override async parse(@@ -441,9 +461,10 @@ class CustomSqlParser extends NodeSqlParser {): Promise<NodeSqlParserResult> {const metadata = getSQLMetadata(opts.state);const engine = metadata.engine;+ const dialect = connectionNameToParserDialect(engine);// For now, always return success for DuckDB- if (engine === DUCKDB_ENGINE) {+ if (isDuckDBConnection(engine, dialect)) {return { success: true, errors: [] };}@@ -451,6 +472,13 @@ class CustomSqlParser extends NodeSqlParser {}}+function isDuckDBConnection(+ engine: ConnectionName,+ dialect: ParserDialects | null,+): boolean {+ return engine === DUCKDB_ENGINE || dialect === "DuckDB";+}+/*** Update the SQL dialect in the editor view.*/