From d6c44577569afa03dab8e94ca12d0b414e0fe6b9 Mon Sep 17 00:00:00 2001 From: jearhe <0verme7753@gmail.com> Date: Wed, 2 Sep 2026 20:36:33 +0800 Subject: [PATCH] fix(editor): substitute sql parameters before explain --- .../__tests__/useSqlExecution.spec.ts | 122 ++++++++++++++++++ .../src/composables/useSqlExecution.ts | 16 ++- .../queryStore.postgresExplain.spec.ts | 22 ++++ 3 files changed, 158 insertions(+), 2 deletions(-) diff --git a/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts index 8af3c4e19a..c445847160 100644 --- a/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts +++ b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts @@ -1322,6 +1322,128 @@ SELECT @value AS Message;`; expect(explainTabSql).toHaveBeenCalledWith("tab-1", sql, "oracle", "explain"); }); + it("explains the resolved PostgreSQL statement after SQL parameter input", async () => { + const sql = "SELECT :var;"; + const resolvedSql = "SELECT 123;"; + const activeTab = ref({ ...queryTab("app"), sql }); + const activeConnection = ref(connection("postgres")); + const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result"); + const queryStore = useQueryStore(); + const explainTabSql = vi.spyOn(queryStore, "explainTabSql").mockResolvedValue({ ok: true, sql: resolvedSql }); + + const execution = useSqlExecution({ + activeTab: computed(() => activeTab.value), + activeConnection: computed(() => activeConnection.value), + executableSql: computed(() => sql), + activeOutputView, + }); + + await execution.tryExplain(); + + expect(execution.showSqlParameterDialog.value).toBe(true); + expect(execution.sqlParameterNames.value.map((parameter) => parameter.name)).toEqual(["var"]); + expect(explainTabSql).not.toHaveBeenCalled(); + + await execution.onSqlParametersConfirm(resolvedSql); + + expect(explainTabSql).toHaveBeenCalledWith("tab-1", resolvedSql, "postgres", "explain"); + }); + + it("explains the analyzed PostgreSQL statement after SQL parameter input", async () => { + const sql = "SELECT :var;"; + const resolvedSql = "SELECT 123;"; + const activeTab = ref({ ...queryTab("app"), sql }); + const activeConnection = ref(connection("postgres")); + const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result"); + const queryStore = useQueryStore(); + const explainTabSql = vi.spyOn(queryStore, "explainTabSql").mockResolvedValue({ ok: true, sql: resolvedSql }); + + const execution = useSqlExecution({ + activeTab: computed(() => activeTab.value), + activeConnection: computed(() => activeConnection.value), + executableSql: computed(() => sql), + activeOutputView, + }); + execution.explainMode.value = "autotrace"; + + await execution.tryExplain(); + + expect(execution.showSqlParameterDialog.value).toBe(true); + expect(explainTabSql).not.toHaveBeenCalled(); + + await execution.onSqlParametersConfirm(resolvedSql); + + expect(explainTabSql).toHaveBeenCalledWith("tab-1", resolvedSql, "postgres", "autotrace"); + }); + + it("explains the string-parameter statement with the dialog's escaped substitution", async () => { + const sql = "SELECT :name;"; + const resolvedSql = "SELECT 'O''Reilly';"; + const activeTab = ref({ ...queryTab("app"), sql }); + const activeConnection = ref(connection("postgres")); + const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result"); + const queryStore = useQueryStore(); + const explainTabSql = vi.spyOn(queryStore, "explainTabSql").mockResolvedValue({ ok: true, sql: resolvedSql }); + + const execution = useSqlExecution({ + activeTab: computed(() => activeTab.value), + activeConnection: computed(() => activeConnection.value), + executableSql: computed(() => sql), + activeOutputView, + }); + + await execution.tryExplain(); + + expect(execution.showSqlParameterDialog.value).toBe(true); + + await execution.onSqlParametersConfirm(resolvedSql); + + expect(explainTabSql).toHaveBeenCalledWith("tab-1", resolvedSql, "postgres", "explain"); + }); + + it("explains a PostgreSQL cast statement without opening the parameter dialog", async () => { + const sql = "SELECT '1'::int;"; + const activeTab = ref({ ...queryTab("app"), sql }); + const activeConnection = ref(connection("postgres")); + const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result"); + const queryStore = useQueryStore(); + const explainTabSql = vi.spyOn(queryStore, "explainTabSql").mockResolvedValue({ ok: true, sql }); + + const execution = useSqlExecution({ + activeTab: computed(() => activeTab.value), + activeConnection: computed(() => activeConnection.value), + executableSql: computed(() => sql), + activeOutputView, + }); + + await execution.tryExplain(); + + expect(execution.showSqlParameterDialog.value).toBe(false); + expect(execution.sqlParameterNames.value).toEqual([]); + expect(explainTabSql).toHaveBeenCalledWith("tab-1", sql, "postgres", "explain"); + }); + + it("explains a parameter-free statement without opening the parameter dialog", async () => { + const sql = "SELECT * FROM orders;"; + const activeTab = ref({ ...queryTab("app"), sql }); + const activeConnection = ref(connection("postgres")); + const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result"); + const queryStore = useQueryStore(); + const explainTabSql = vi.spyOn(queryStore, "explainTabSql").mockResolvedValue({ ok: true, sql }); + + const execution = useSqlExecution({ + activeTab: computed(() => activeTab.value), + activeConnection: computed(() => activeConnection.value), + executableSql: computed(() => sql), + activeOutputView, + }); + + await execution.tryExplain(); + + expect(execution.showSqlParameterDialog.value).toBe(false); + expect(explainTabSql).toHaveBeenCalledWith("tab-1", sql, "postgres", "explain"); + }); + it("keeps the new-result-tab intent through Redis command confirmation", async () => { const sql = "DEL user:1"; const activeTab = ref({ ...queryTab("0"), sql }); diff --git a/apps/desktop/src/composables/useSqlExecution.ts b/apps/desktop/src/composables/useSqlExecution.ts index c3bbd0f4f9..c2a16ae067 100644 --- a/apps/desktop/src/composables/useSqlExecution.ts +++ b/apps/desktop/src/composables/useSqlExecution.ts @@ -541,9 +541,8 @@ export function useSqlExecution(deps: { return t("explain.emptySql"); } - async function tryExplain(sqlOverride?: SqlExecutionOverride) { + async function runExplain(sql: string) { const tab = deps.activeTab.value; - const { sql } = await resolvedExecutableSql(sqlOverride); if (!tab || !sql.trim()) { toast(t("explain.emptySql")); return; @@ -562,6 +561,19 @@ export function useSqlExecution(deps: { if (current?.explainError) toast(current.explainError, 5000); } + async function tryExplain(sqlOverride?: SqlExecutionOverride) { + const tab = deps.activeTab.value; + const { sql, sourceOffset } = await resolvedExecutableSql(sqlOverride); + if (!tab || !sql.trim()) { + toast(t("explain.emptySql")); + return; + } + // Resolve SQL template variables exactly like tryExecute so EXPLAIN never runs the raw + // placeholders (e.g. `EXPLAIN (FORMAT JSON) SELECT :var;` fails on PostgreSQL). + if (supportsSqlTemplateParameters(deps.activeConnection.value, sql) && prepareSqlParameterDialog(sql, sourceOffset, {}, (resolvedSql) => runExplain(resolvedSql))) return; + await runExplain(sql); + } + async function onDangerConfirm() { const sql = pendingDangerSql.value; const sourceOffset = pendingDangerSourceOffset.value; diff --git a/apps/desktop/src/stores/__tests__/queryStore.postgresExplain.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.postgresExplain.spec.ts index 6078d79122..a98c7e8def 100644 --- a/apps/desktop/src/stores/__tests__/queryStore.postgresExplain.spec.ts +++ b/apps/desktop/src/stores/__tests__/queryStore.postgresExplain.spec.ts @@ -151,4 +151,26 @@ describe("queryStore PostgreSQL EXPLAIN ANALYZE", () => { expect(mocks.buildExplainSql).toHaveBeenCalledWith("questdb", SOURCE_SQL); }); + + it("wraps a resolved statement whose variables were substituted before explain", async () => { + const resolvedSql = "SELECT 123"; + const { useQueryStore } = await import("@/stores/queryStore"); + const store = useQueryStore(); + const tabId = store.createTab("pg-1", "shop", "Query", "query", "public"); + + await store.explainTabSql(tabId, resolvedSql, "postgres"); + + expect(mocks.buildExplainSql).toHaveBeenCalledWith("postgres", resolvedSql); + }); + + it("keeps the analyze flag for a resolved statement whose variables were substituted", async () => { + const resolvedSql = "SELECT 123"; + const { useQueryStore } = await import("@/stores/queryStore"); + const store = useQueryStore(); + const tabId = store.createTab("pg-1", "shop", "Query", "query", "public"); + + await store.explainTabSql(tabId, resolvedSql, "postgres", "autotrace"); + + expect(mocks.buildExplainSql).toHaveBeenCalledWith("postgres", resolvedSql, "json", true); + }); });