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。

fix(table): map indexless batch drop results to the plan

lxk955e08b81e2ce54
diff --git a/apps/desktop/src/lib/__tests__/table/batchTableDrop.spec.ts b/apps/desktop/src/lib/__tests__/table/batchTableDrop.spec.ts
index e6e2ce48c3..c53db434a8 100644
--- a/apps/desktop/src/lib/__tests__/table/batchTableDrop.spec.ts
+++ b/apps/desktop/src/lib/__tests__/table/batchTableDrop.spec.ts
@@ -72,4 +72,85 @@ describe("batch table drop", () => {
expect(result.succeeded).toEqual([]);
expect(result.failed?.message).toBe("Batch drop did not report a result for every statement");
});
+
+ it("succeeds for single table drop when backend returns an indexless result", async () => {
+ const singlePlan = [{ target: "platforms", sql: "DROP TABLE `platforms`" }];
+ const onProgress = vi.fn();
+ const result = await runBatchTableDrop({
+ databaseType: "mysql",
+ plan: singlePlan,
+ executeStatement: vi.fn(),
+ executeBatch: async () => [queryResult()],
+ onProgress,
+ });
+
+ expect(result.succeeded).toEqual(["platforms"]);
+ expect(result.failed).toBeUndefined();
+ expect(onProgress).toHaveBeenCalledWith({ completed: 1, total: 1, success: true });
+ });
+
+ it("reports failure for single table drop when execution error occurs", async () => {
+ const singlePlan = [{ target: "platforms", sql: "DROP TABLE `platforms`" }];
+ const onProgress = vi.fn();
+ const result = await runBatchTableDrop({
+ databaseType: "oceanbase-oracle",
+ plan: singlePlan,
+ executeStatement: vi.fn(),
+ executeBatch: async () => [
+ queryResult({
+ execution_error: true,
+ error: {
+ version: 1,
+ code: "OBE-00942",
+ messageKey: "error.database",
+ messageParams: {},
+ source: "agent",
+ operationOutcome: "unknown",
+ detail: "table or view does not exist",
+ },
+ }),
+ ],
+ onProgress,
+ });
+
+ expect(result.succeeded).toEqual([]);
+ expect(result.failed?.message).toBe("table or view does not exist");
+ });
+
+ it("maps 1-to-1 sequential indexless batch results when lengths match", async () => {
+ const twoPlan = [
+ { target: "orders", sql: "DROP TABLE orders" },
+ { target: "customers", sql: "DROP TABLE customers" },
+ ];
+ const onProgress = vi.fn();
+ const result = await runBatchTableDrop({
+ databaseType: "mysql",
+ plan: twoPlan,
+ executeStatement: vi.fn(),
+ executeBatch: async () => [queryResult(), queryResult({ execution_error: true, rows: [["foreign key constraint fails"]] })],
+ onProgress,
+ });
+
+ expect(result.succeeded).toEqual(["orders"]);
+ expect(result.failed?.message).toBe("foreign key constraint fails");
+ });
+
+ it("handles empty drop plan immediately without executing queries", async () => {
+ const executeStatement = vi.fn();
+ const executeBatch = vi.fn();
+ const onProgress = vi.fn();
+ const result = await runBatchTableDrop({
+ databaseType: "mysql",
+ plan: [],
+ executeStatement,
+ executeBatch,
+ onProgress,
+ });
+
+ expect(result.succeeded).toEqual([]);
+ expect(result.failed).toBeUndefined();
+ expect(executeStatement).not.toHaveBeenCalled();
+ expect(executeBatch).not.toHaveBeenCalled();
+ expect(onProgress).not.toHaveBeenCalled();
+ });
});
diff --git a/apps/desktop/src/lib/table/batchTableDrop.ts b/apps/desktop/src/lib/table/batchTableDrop.ts
index cd95a7532c..5fd3142c86 100644
--- a/apps/desktop/src/lib/table/batchTableDrop.ts
+++ b/apps/desktop/src/lib/table/batchTableDrop.ts
@@ -25,7 +25,8 @@ interface RunBatchTableDropOptions<T> {
}
function batchDropError(result: QueryResult): Error {
- return new Error(String(result.rows[0]?.[0] ?? "Batch drop failed"));
+ const message = result.error?.detail || result.rows[0]?.[0];
+ return new Error(String(message ?? "Batch drop failed"));
}
function isAtomicIndexlessBatch(databaseType: DatabaseType | undefined): boolean {
@@ -33,6 +34,10 @@ function isAtomicIndexlessBatch(databaseType: DatabaseType | undefined): boolean
}
export async function runBatchTableDrop<T>({ databaseType, plan, executeStatement, executeBatch, onProgress }: RunBatchTableDropOptions<T>): Promise<BatchTableDropResult<T>> {
+ if (plan.length === 0) {
+ return { succeeded: [] };
+ }
+
if (databaseType === "sqlserver") {
const succeeded: T[] = [];
for (let index = 0; index < plan.length; index += 1) {
@@ -50,16 +55,30 @@ export async function runBatchTableDrop<T>({ databaseType, plan, executeStatemen
const results = await executeBatch(plan.map(({ sql }) => sql).join(";\n"), onProgress);
const failedResult = results.find((result) => result.execution_error === true);
+
+ const hasStatementIndexes = results.some((result) => Number.isInteger(result.statement_index));
+ if (hasStatementIndexes) {
+ const succeededIndexes = new Set(results.filter((result) => result.execution_error !== true && Number.isInteger(result.statement_index)).map((result) => result.statement_index!));
+ const succeeded = plan.filter((_, index) => succeededIndexes.has(index)).map(({ target }) => target);
+ if (failedResult) return { succeeded, failed: batchDropError(failedResult) };
+ if (succeeded.length !== plan.length) {
+ return { succeeded, failed: new Error("Batch drop did not report a result for every statement") };
+ }
+ return { succeeded };
+ }
+
if (!failedResult && isAtomicIndexlessBatch(databaseType) && results.every((result) => !Number.isInteger(result.statement_index))) {
onProgress({ completed: plan.length, total: plan.length, success: true });
return { succeeded: plan.map(({ target }) => target) };
}
- const succeededIndexes = new Set(results.filter((result) => result.execution_error !== true && Number.isInteger(result.statement_index)).map((result) => result.statement_index!));
- const succeeded = plan.filter((_, index) => succeededIndexes.has(index)).map(({ target }) => target);
- if (failedResult) return { succeeded, failed: batchDropError(failedResult) };
- if (succeeded.length !== plan.length) {
- return { succeeded, failed: new Error("Batch drop did not report a result for every statement") };
+ if (results.length === plan.length) {
+ const succeeded = plan.filter((_, index) => results[index] && results[index]!.execution_error !== true).map(({ target }) => target);
+ if (failedResult) return { succeeded, failed: batchDropError(failedResult) };
+ onProgress({ completed: plan.length, total: plan.length, success: true });
+ return { succeeded };
}
- return { succeeded };
+
+ if (failedResult) return { succeeded: [], failed: batchDropError(failedResult) };
+ return { succeeded: [], failed: new Error("Batch drop did not report a result for every statement") };
}