Skip to content

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.

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.ts
index 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.ts
index 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 codemirror
const 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 typing
private 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 delay
return new Promise((resolve) => {
+ this.pendingValidationResolve = resolve;
this.validationTimeout = window.setTimeout(async () => {
+ this.validationTimeout = null;
+
// Only validate if the editor is still focused
if (!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 focused
if (!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.
*/