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。

feat(export): queue manual desktop exports

efeire9d8ca5dc2a5f
diff --git a/apps/desktop/src/components/document/DocumentBrowser.vue b/apps/desktop/src/components/document/DocumentBrowser.vue
index c422b73420..20d6515f6d 100644
--- a/apps/desktop/src/components/document/DocumentBrowser.vue
+++ b/apps/desktop/src/components/document/DocumentBrowser.vue
@@ -21,8 +21,10 @@ import LightTooltip from "@/components/ui/LightTooltip.vue";
import { Switch } from "@/components/ui/switch";
import QueryLoadingState from "@/components/common/QueryLoadingState.vue";
import * as api from "@/lib/backend/api";
+import { SnapshotCompletionError, type ExportReadControl } from "@/lib/export/snapshotCompletion";
import type { DynamoDbIndexInfo, DynamoDbTableDescription } from "@/lib/backend/api";
import { useConnectionStore } from "@/stores/connectionStore";
+import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
import { getDataGridConditionSuggestionPosition, type DataGridConditionSuggestionPosition } from "@/lib/dataGrid/dataGridConditionSuggestionPosition";
import { clampSearchSplitWidth } from "@/lib/dataGrid/dataGridSearchSplit";
import { documentViewerFontStyle } from "@/lib/document/documentViewerFontStyle";
@@ -462,8 +464,7 @@ if (restoredDocumentData) {
}
const elasticsearchMappingFields = ref<ColumnInfo[]>([]);
-function elasticsearchGridColumnTypesFor(columns: readonly string[]): string[] {
- const mappingTypes = elasticsearchFieldTypes.value;
+function elasticsearchGridColumnTypesFor(columns: readonly string[], mappingTypes = elasticsearchFieldTypes.value): string[] {
return columns.map((column) => {
// Elasticsearch metadata fields are not part of an index mapping, but they
// are textual identifiers in the document grid just like mapped keywords.
@@ -474,8 +475,8 @@ function elasticsearchGridColumnTypesFor(columns: readonly string[]): string[] {
const elasticsearchGridColumnTypes = computed(() => elasticsearchGridColumnTypesFor(lastGridColumns.value));
const solrSchemaFields = ref<ColumnInfo[]>([]);
const solrFieldTypes = computed(() => new Map(solrSchemaFields.value.map((field) => [field.name, field.data_type])));
-function solrGridColumnTypesFor(columns: readonly string[]): string[] {
- return columns.map((column) => (column === "_id" ? "string" : (solrFieldTypes.value.get(column) ?? "")));
+function solrGridColumnTypesFor(columns: readonly string[], fieldTypes = solrFieldTypes.value): string[] {
+ return columns.map((column) => (column === "_id" ? "string" : (fieldTypes.get(column) ?? "")));
}
const solrGridColumnTypes = computed(() => solrGridColumnTypesFor(lastGridColumns.value));
const dynamodbTableDescription = ref<DynamoDbTableDescription | null>(null);
@@ -650,7 +651,7 @@ const gridResult = computed<QueryResult>(() => {
};
});
-async function exportAllDocumentStoreDocuments(onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void): Promise<QueryResult | undefined> {
+function captureDocumentStoreExport(queued = true) {
const kind = documentStoreProvider.value.kind;
if (kind !== "mongodb" && kind !== "dynamodb" && kind !== "elasticsearch" && kind !== "solr") return undefined;
@@ -662,71 +663,119 @@ async function exportAllDocumentStoreDocuments(onProgress?: (info: { rowsExporte
const exportSettings = settingsStore.editorSettings;
const batchSize = Math.max(1, Math.trunc(exportSettings.exportBatchSize));
const rowLimit = exportSettings.exportRowLimitEnabled ? Math.max(0, Math.trunc(exportSettings.exportRowLimit)) : kind === "dynamodb" ? DYNAMODB_DEFAULT_EXPORT_ROW_LIMIT : Number.POSITIVE_INFINITY;
- const exportExecutionId = uuid();
- const exportStartedAt = performance.now();
- const exportedDocuments: JsonRecord[] = [];
- let exportedCopyDocuments: JsonRecord[] | undefined = kind === "mongodb" ? [] : undefined;
- let totalRows: number | null = null;
- let cursor: string | undefined;
- let lastCursor: string | undefined;
- const seenCursors = new Set<string>();
+ const fallbackColumns = [...gridResult.value.columns];
+ const mappingTypes = new Map(elasticsearchFieldTypes.value);
+ const fieldTypes = new Map(solrFieldTypes.value);
+ const config = queued ? connectionStore.getConfig(connectionId) : undefined;
+ const fingerprint = config ? connectionConfigFingerprint(config) : undefined;
+
+ return async (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void, control?: ExportReadControl): Promise<QueryResult | undefined> => {
+ let unknownError: SnapshotCompletionError | undefined;
+ const check = () => {
+ if (unknownError) throw unknownError;
+ if (control?.signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ if (queued) {
+ const current = connectionStore.getConfig(connectionId);
+ if (!current || connectionConfigFingerprint(current) !== fingerprint) throw new Error(t("exportProgress.connectionChanged"));
+ }
+ };
+ try {
+ check();
+ if (queued) {
+ await connectionStore.ensureConnected(connectionId);
+ check();
+ }
+ const exportExecutionId = uuid();
+ const exportStartedAt = performance.now();
+ const exportedDocuments: JsonRecord[] = [];
+ let exportedCopyDocuments: JsonRecord[] | undefined = kind === "mongodb" ? [] : undefined;
+ let totalRows: number | null = null;
+ let cursor: string | undefined;
+ let lastCursor: string | undefined;
+ const seenCursors = new Set<string>();
- try {
- while (exportedDocuments.length < rowLimit) {
- const requestLimit = Math.min(batchSize, kind === "dynamodb" ? 1000 : kind === "elasticsearch" ? ELASTICSEARCH_DEFAULT_MAX_RESULT_WINDOW : Number.POSITIVE_INFINITY, rowLimit - exportedDocuments.length);
- if (requestLimit <= 0) break;
- if (cursor) lastCursor = cursor;
- const result = await api.documentFindDocuments(connectionId, database, collection, kind === "dynamodb" || kind === "elasticsearch" ? 0 : exportedDocuments.length, requestLimit, filter, undefined, sort, undefined, exportExecutionId, cursor, kind === "elasticsearch");
- const pageDocuments = result.documents.slice(0, requestLimit).map(asRecord);
- exportedDocuments.push(...pageDocuments);
-
- if (kind === "mongodb" && exportedCopyDocuments) {
- if (result.extended_documents?.length === result.documents.length) {
- exportedCopyDocuments.push(...result.extended_documents.slice(0, pageDocuments.length).map(asRecord));
- } else {
- exportedCopyDocuments = undefined;
+ try {
+ while (exportedDocuments.length < rowLimit) {
+ check();
+ const requestLimit = Math.min(batchSize, kind === "dynamodb" ? 1000 : kind === "elasticsearch" ? ELASTICSEARCH_DEFAULT_MAX_RESULT_WINDOW : Number.POSITIVE_INFINITY, rowLimit - exportedDocuments.length);
+ if (requestLimit <= 0) break;
+ if (cursor) lastCursor = cursor;
+ const result = await api.documentFindDocuments(connectionId, database, collection, kind === "dynamodb" || kind === "elasticsearch" ? 0 : exportedDocuments.length, requestLimit, filter, undefined, sort, undefined, exportExecutionId, cursor, kind === "elasticsearch").catch((error) => {
+ if (!queued) throw error;
+ unknownError = new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ throw unknownError;
+ });
+ if (queued && result.next_cursor) lastCursor = result.next_cursor;
+ check();
+ const pageDocuments = result.documents.slice(0, requestLimit).map(asRecord);
+ exportedDocuments.push(...pageDocuments);
+
+ if (kind === "mongodb" && exportedCopyDocuments) {
+ if (result.extended_documents?.length === result.documents.length) {
+ exportedCopyDocuments.push(...result.extended_documents.slice(0, pageDocuments.length).map(asRecord));
+ } else {
+ exportedCopyDocuments = undefined;
+ }
+ }
+
+ if ((kind === "mongodb" || kind === "elasticsearch" || kind === "solr") && result.total_is_exact !== false) totalRows = Math.min(result.total, rowLimit);
+ onProgress?.({ rowsExported: exportedDocuments.length, totalRows });
+
+ if (kind === "dynamodb" || kind === "elasticsearch") {
+ cursor = result.next_cursor;
+ if (!cursor) break;
+ if (seenCursors.has(cursor)) throw new Error(kind === "dynamodb" ? t("dynamodb.repeatedCursor") : "Elasticsearch cursor repeated during export");
+ seenCursors.add(cursor);
+ continue;
+ }
+
+ const reachedExactTotal = result.total_is_exact !== false && exportedDocuments.length >= result.total;
+ if (pageDocuments.length === 0 || pageDocuments.length < requestLimit || reachedExactTotal) break;
+ }
+ } finally {
+ if (kind === "elasticsearch") {
+ const cursorToClose = lastCursor ?? cursor;
+ if (cursorToClose) {
+ if (queued) {
+ try {
+ await api.closeQuerySession(connectionId, database, cursorToClose);
+ } catch (error) {
+ unknownError ??= new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ }
+ } else void closeElasticsearchCursor(cursorToClose);
+ }
}
}
-
- if ((kind === "mongodb" || kind === "elasticsearch" || kind === "solr") && result.total_is_exact !== false) totalRows = Math.min(result.total, rowLimit);
- onProgress?.({ rowsExported: exportedDocuments.length, totalRows });
+ if (unknownError) throw unknownError;
if (kind === "dynamodb" || kind === "elasticsearch") {
- cursor = result.next_cursor;
- if (!cursor) break;
- if (seenCursors.has(cursor)) throw new Error(kind === "dynamodb" ? t("dynamodb.repeatedCursor") : "Elasticsearch cursor repeated during export");
- seenCursors.add(cursor);
- continue;
+ const truncatedByLimit = !!cursor && exportedDocuments.length >= rowLimit;
+ totalRows = truncatedByLimit ? null : exportedDocuments.length;
+ onProgress?.({ rowsExported: exportedDocuments.length, totalRows });
+ if (truncatedByLimit) {
+ toast(kind === "dynamodb" ? t("dynamodb.exportLimitReached", { count: rowLimit }) : `Elasticsearch export limit reached (${rowLimit})`, 6000);
+ }
}
- const reachedExactTotal = result.total_is_exact !== false && exportedDocuments.length >= result.total;
- if (pageDocuments.length === 0 || pageDocuments.length < requestLimit || reachedExactTotal) break;
- }
- } finally {
- if (kind === "elasticsearch") {
- const cursorToClose = lastCursor ?? cursor;
- if (cursorToClose) void closeElasticsearchCursor(cursorToClose);
- }
- }
-
- if (kind === "dynamodb" || kind === "elasticsearch") {
- const truncatedByLimit = !!cursor && exportedDocuments.length >= rowLimit;
- totalRows = truncatedByLimit ? null : exportedDocuments.length;
- onProgress?.({ rowsExported: exportedDocuments.length, totalRows });
- if (truncatedByLimit) {
- toast(kind === "dynamodb" ? t("dynamodb.exportLimitReached", { count: rowLimit }) : `Elasticsearch export limit reached (${rowLimit})`, 6000);
+ // Exports consume source text (CSV/SQL), not the live grid's BSON-faithful
+ // cell encoding, so every document store keeps plain JSON cells here.
+ const result = mongoDocumentsToQueryResult(exportedDocuments, performance.now() - exportStartedAt, totalRows ?? exportedDocuments.length, exportedCopyDocuments, totalRows !== null, { documentGridValues: false });
+ if (result.columns.length === 0) result.columns = fallbackColumns;
+ result.column_types = kind === "mongodb" ? mongoDocumentGridColumnTypes(exportedDocuments, result.columns) : kind === "elasticsearch" ? elasticsearchGridColumnTypesFor(result.columns, mappingTypes) : kind === "solr" ? solrGridColumnTypesFor(result.columns, fieldTypes) : undefined;
+ result.affected_rows = exportedDocuments.length;
+ result.truncated = (kind === "dynamodb" || kind === "elasticsearch") && !!cursor && exportedDocuments.length >= rowLimit;
+ result.has_more = result.truncated;
+ return result;
+ } catch (error) {
+ if (unknownError) throw unknownError;
+ if (!queued || error instanceof SnapshotCompletionError) throw error;
+ throw new SnapshotCompletionError("failed", error instanceof Error ? error.message : String(error));
}
- }
+ };
+}
- // Exports consume source text (CSV/SQL), not the live grid's BSON-faithful
- // cell encoding, so every document store keeps plain JSON cells here.
- const result = mongoDocumentsToQueryResult(exportedDocuments, performance.now() - exportStartedAt, totalRows ?? exportedDocuments.length, exportedCopyDocuments, totalRows !== null, { documentGridValues: false });
- if (result.columns.length === 0) result.columns = gridResult.value.columns;
- result.column_types = kind === "mongodb" ? mongoDocumentGridColumnTypes(exportedDocuments, result.columns) : kind === "elasticsearch" ? elasticsearchGridColumnTypesFor(result.columns) : kind === "solr" ? solrGridColumnTypesFor(result.columns) : undefined;
- result.affected_rows = exportedDocuments.length;
- result.truncated = (kind === "dynamodb" || kind === "elasticsearch") && !!cursor && exportedDocuments.length >= rowLimit;
- result.has_more = result.truncated;
- return result;
+async function exportAllDocumentStoreDocuments(onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void): Promise<QueryResult | undefined> {
+ return captureDocumentStoreExport(false)?.(onProgress);
}
const expandedDocumentFilterFieldPaths = ref<Set<string>>(new Set());
const elasticsearchFieldTypes = computed(() => new Map(elasticsearchMappingFields.value.map((field) => [field.name, field.data_type])));
@@ -3001,6 +3050,7 @@ defineExpose({ focusSearch });
:load-all-rows-enabled="false"
:count-total-rows="countExactDocumentTotal"
:full-export-result="documentStoreProvider.kind === 'mongodb' || documentStoreProvider.kind === 'dynamodb' || documentStoreProvider.kind === 'elasticsearch' ? exportAllDocumentStoreDocuments : undefined"
+ :capture-full-export-result="documentStoreProvider.kind === 'mongodb' || documentStoreProvider.kind === 'dynamodb' || documentStoreProvider.kind === 'elasticsearch' ? captureDocumentStoreExport : undefined"
@sort="onSort"
@reload="refreshDocuments"
@paginate="(offset: number, limit: number) => paginate(offset, limit)"
diff --git a/apps/desktop/src/components/document/__tests__/DocumentBrowserEmptyCollection.spec.ts b/apps/desktop/src/components/document/__tests__/DocumentBrowserEmptyCollection.spec.ts
index 6cee7b7b64..7bcf4fc17b 100644
--- a/apps/desktop/src/components/document/__tests__/DocumentBrowserEmptyCollection.spec.ts
+++ b/apps/desktop/src/components/document/__tests__/DocumentBrowserEmptyCollection.spec.ts
@@ -1,13 +1,15 @@
// @vitest-environment happy-dom
-import { createApp, defineComponent, h, nextTick, type App } from "vue";
+import { createApp, defineComponent, h, nextTick, reactive, type App } from "vue";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
const backend = vi.hoisted(() => ({
documentFindDocuments: vi.fn(),
documentCountDocuments: vi.fn(),
cancelQuery: vi.fn(),
+ closeQuerySession: vi.fn(),
ensureConnected: vi.fn(),
+ getConfig: vi.fn(),
documentInsertDocument: vi.fn(),
documentUpdateDocument: vi.fn(),
documentDeleteDocument: vi.fn(),
@@ -18,6 +20,7 @@ const dataGrid = vi.hoisted(() => ({
reload: undefined as (() => Promise<void>) | undefined,
rows: [] as unknown[],
columns: [] as string[],
+ captureExport: undefined as (() => ((progress?: unknown, control?: { signal: AbortSignal }) => Promise<unknown>) | undefined) | undefined,
}));
const settings = vi.hoisted(() => ({
@@ -50,6 +53,7 @@ vi.mock("@/lib/backend/api", () => ({
documentCountDocuments: backend.documentCountDocuments,
dynamodbDescribeTable: vi.fn(),
cancelQuery: backend.cancelQuery,
+ closeQuerySession: backend.closeQuerySession,
documentInsertDocument: backend.documentInsertDocument,
documentUpdateDocument: backend.documentUpdateDocument,
documentDeleteDocument: backend.documentDeleteDocument,
@@ -57,7 +61,7 @@ vi.mock("@/lib/backend/api", () => ({
}));
vi.mock("@/stores/connectionStore", () => ({
- useConnectionStore: () => ({ ensureConnected: backend.ensureConnected }),
+ useConnectionStore: () => ({ ensureConnected: backend.ensureConnected, getConfig: backend.getConfig }),
}));
vi.mock("@/stores/settingsStore", () => ({
@@ -77,6 +81,7 @@ vi.mock("@/components/grid/DataGrid.vue", () => {
pageOffset: { type: Number, required: false },
pageLimit: { type: Number, required: false },
pageSizePreference: { type: String, required: false },
+ captureFullExportResult: { type: Function, required: false },
},
setup(props, { attrs, expose }) {
dataGrid.reload = attrs.onReload as typeof dataGrid.reload;
@@ -101,6 +106,7 @@ vi.mock("@/components/grid/DataGrid.vue", () => {
resetInfiniteScrollState: vi.fn(),
});
return () => {
+ dataGrid.captureExport = props.captureFullExportResult as typeof dataGrid.captureExport;
const result = props.result as { rows: unknown[]; columns?: string[] };
dataGrid.rows = result.rows;
dataGrid.columns = result.columns ?? [];
@@ -159,12 +165,12 @@ async function flushUi() {
}
}
-async function mountBrowser() {
+async function mountBrowser(databaseType = "mongodb") {
app = createApp(DocumentBrowser, {
connectionId: "mongo-1",
database: "test",
collection: "docs",
- databaseType: "mongodb",
+ databaseType,
});
app.mount(root!);
await flushUi();
@@ -190,16 +196,19 @@ beforeEach(async () => {
backend.documentFindDocuments.mockReset();
backend.documentCountDocuments.mockReset();
backend.cancelQuery.mockReset();
+ backend.closeQuerySession.mockReset().mockResolvedValue(undefined);
backend.ensureConnected.mockReset();
backend.documentInsertDocument.mockReset();
backend.documentUpdateDocument.mockReset();
backend.documentDeleteDocument.mockReset();
backend.documentSaveMeilisearchBatch.mockReset();
backend.ensureConnected.mockResolvedValue(undefined);
+ backend.getConfig.mockReturnValue({ id: "mongo-1", name: "Mongo", db_type: "mongodb" });
backend.documentCountDocuments.mockResolvedValue(0);
dataGrid.reload = undefined;
dataGrid.rows = [];
dataGrid.columns = [];
+ dataGrid.captureExport = undefined;
root = document.createElement("div");
document.body.appendChild(root);
@@ -214,6 +223,101 @@ afterEach(() => {
});
describe("DocumentBrowser empty collection refresh entry (issue #8093)", () => {
+ it("preserves Extended JSON across all captured Mongo export pages", async () => {
+ backend.documentFindDocuments.mockResolvedValue(documentResult(1, 1, 1));
+ await mountBrowser();
+ const fetch = dataGrid.captureExport!()!;
+ backend.documentFindDocuments.mockClear();
+ const extended = [1, 2, 3].map((id) => ({ _id: { $oid: String(id).padStart(24, "0") }, value: { $numberLong: String(id) } }));
+ backend.documentFindDocuments.mockResolvedValueOnce({ ...documentResult(1, 2, 3), extended_documents: extended.slice(0, 2) });
+ backend.documentFindDocuments.mockResolvedValueOnce({ ...documentResult(3, 1, 3), extended_documents: extended.slice(2) });
+ const result = (await fetch()) as { mongo_copy_documents: unknown[]; rows: unknown[]; has_more: boolean };
+ expect(backend.documentFindDocuments).toHaveBeenCalledTimes(2);
+ expect(result.rows).toHaveLength(3);
+ expect(result.mongo_copy_documents).toEqual(extended);
+ expect(result.has_more).toBe(false);
+ expect(backend.closeQuerySession).not.toHaveBeenCalled();
+ });
+
+ it.each(["resolve", "reject"] as const)("waits for captured Elasticsearch cursor cleanup (%s)", async (completion) => {
+ backend.getConfig.mockReturnValue({ id: "mongo-1", name: "ES", db_type: "elasticsearch" });
+ backend.documentFindDocuments.mockResolvedValue(documentResult(1, 1, 1));
+ await mountBrowser("elasticsearch");
+ const fetch = dataGrid.captureExport!()!;
+ backend.documentFindDocuments.mockClear();
+ backend.documentFindDocuments.mockResolvedValueOnce({ ...documentResult(1, 2, 3), next_cursor: "export-cursor" });
+ backend.documentFindDocuments.mockResolvedValueOnce(documentResult(3, 1, 3));
+ let close!: () => void;
+ let fail!: (error: Error) => void;
+ backend.closeQuerySession.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve, reject) => {
+ close = resolve;
+ fail = reject;
+ }),
+ );
+ let settled = false;
+ const pending = fetch()
+ .catch((error) => error)
+ .finally(() => {
+ settled = true;
+ });
+ await vi.waitFor(() => expect(backend.closeQuerySession).toHaveBeenCalledWith("mongo-1", "test", "export-cursor"));
+ expect(settled).toBe(false);
+ if (completion === "resolve") close();
+ else fail(new Error("cursor close reply lost"));
+ const result = await pending;
+ if (completion === "resolve") expect(result).toMatchObject({ rows: expect.any(Array), has_more: false });
+ else expect(result).toMatchObject({ status: "unknown" });
+ });
+
+ it.each(["resolve", "reject"] as const)("waits for a captured document request after cancellation (%s)", async (completion) => {
+ backend.documentFindDocuments.mockResolvedValue(documentResult(1, 1, 1));
+ await mountBrowser();
+ const fetch = dataGrid.captureExport!()!;
+ backend.documentFindDocuments.mockClear();
+ let resolveRead!: (value: unknown) => void;
+ let rejectRead!: (error: Error) => void;
+ backend.documentFindDocuments.mockImplementationOnce(
+ () =>
+ new Promise((resolve, reject) => {
+ resolveRead = resolve;
+ rejectRead = reject;
+ }),
+ );
+ const controller = new AbortController();
+ const pending = fetch(undefined, { signal: controller.signal }).catch((error) => error);
+ await vi.waitFor(() => expect(backend.documentFindDocuments).toHaveBeenCalledOnce());
+ let settled = false;
+ void pending.then(() => {
+ settled = true;
+ });
+ controller.abort();
+ await flushUi();
+ expect(settled).toBe(false);
+ if (completion === "resolve") resolveRead(documentResult(1, 2, 4));
+ else rejectRead(new Error("transport lost"));
+ expect(await pending).toMatchObject({ status: completion === "resolve" ? "cancelled" : "unknown" });
+ expect(backend.documentFindDocuments).toHaveBeenCalledOnce();
+ expect(backend.cancelQuery).not.toHaveBeenCalled();
+ });
+
+ it("keeps a captured export bound to its original database and collection", async () => {
+ backend.documentFindDocuments.mockResolvedValue(documentResult(1, 1, 1));
+ const props = reactive({ connectionId: "mongo-1", database: "test", collection: "docs", databaseType: "mongodb" as const });
+ app = createApp({ render: () => h(DocumentBrowser, props) });
+ app.mount(root!);
+ await flushUi();
+ const fetch = dataGrid.captureExport!()!;
+ props.database = "other";
+ props.collection = "private_docs";
+ await flushUi();
+ backend.documentFindDocuments.mockClear();
+ await fetch();
+ expect(backend.documentFindDocuments).toHaveBeenCalledOnce();
+ expect(backend.documentFindDocuments.mock.calls[0]!.slice(0, 3)).toEqual(["mongo-1", "test", "docs"]);
+ });
+
it("still reports non-empty columns for a collection that has never returned any document", async () => {
backend.documentFindDocuments.mockResolvedValueOnce(documentResult(1, 0, 0));
diff --git a/apps/desktop/src/components/export/DatabaseExportDialog.vue b/apps/desktop/src/components/export/DatabaseExportDialog.vue
index f8a35c860e..cc3c733e92 100644
--- a/apps/desktop/src/components/export/DatabaseExportDialog.vue
+++ b/apps/desktop/src/components/export/DatabaseExportDialog.vue
@@ -26,10 +26,16 @@ import { revealExportedPath } from "@/lib/export/exportPath";
import { translateBackendError } from "@/i18n/backend-errors";
import { databaseExportFileStem, loadSavedDatabaseExportOptions, MAX_SPLIT_SQL_PART_MB, MIN_SPLIT_SQL_PART_MB, saveDatabaseExportOptions, sortDatabaseTableNames } from "@/lib/export/databaseExportOptions";
import { notifyExportComplete } from "@/lib/export/exportReveal";
+import ExportExecutionMode from "@/components/export/ExportExecutionMode.vue";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
+import type { ExportTask } from "@/composables/useExportTracker";
+import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
const { t } = useI18n();
const { toast } = useToast();
-const { addDatabaseExportTask, updateDatabaseExportTask } = useExportTracker();
+const exportTracker = useExportTracker();
+const { addDatabaseExportTask, updateDatabaseExportTask } = exportTracker;
const open = defineModel<boolean>("open", { default: false });
const store = useConnectionStore();
@@ -80,6 +86,9 @@ const omitAutoIncrement = ref(savedOptions.omitAutoIncrement);
const preserveOriginalLanguage = ref(savedOptions.preserveOriginalLanguage);
const splitSqlOutput = ref(savedOptions.splitSqlOutput);
const splitSqlPartMaxMb = ref(savedOptions.splitSqlPartMaxMb);
+const executionMode = ref<ManualExportMode>("immediate");
+const desktopTaskStatus = ref<ExportTask["status"] | null>(null);
+let disposed = false;
function applyStoredExportOptions() {
const saved = loadSavedDatabaseExportOptions();
@@ -158,6 +167,7 @@ onMounted(() => {
}, 1000);
});
onBeforeUnmount(() => {
+ disposed = true;
if (elapsedTimer) clearInterval(elapsedTimer);
});
@@ -398,8 +408,232 @@ async function buildExportPlanForDatabases(dbs: string[]): Promise<AllDatabaseEx
return buildAllDatabaseExportPlan({ databases: dbs, schemaAware, schemasByDatabase, dbType });
}
+async function startDesktopExport() {
+ const config = store.getConfig(connectionId.value);
+ if (!config) return;
+ const captured = {
+ connectionId: connectionId.value,
+ fingerprint: connectionConfigFingerprint(config),
+ connectionType: config.db_type,
+ database: database.value,
+ schema: isPostgresAllSchemas.value ? "" : schema.value,
+ allDatabases: exportAllDatabases.value,
+ databases: [...selectedDatabases.value],
+ tables: [...selectedTables.value],
+ mode: executionMode.value,
+ split: splitSqlOutput.value,
+ request: {
+ selectedTables: !isPostgresAllSchemas.value && (includeStructure.value || includeData.value) ? buildSelectedTablesPayload(tables.value, selectedTables.value) : undefined,
+ includeStructure: includeStructure.value,
+ includeData: includeData.value,
+ insertDialect: insertDialect.value,
+ insertMode: insertMode.value,
+ includeObjects: includeObjects.value,
+ includeCreateDatabase: includeCreateDatabase.value,
+ dropTableIfExists: dropTableIfExists.value,
+ omitAutoIncrement: omitAutoIncrement.value,
+ preserveOriginalLanguage: preserveOriginalLanguage.value,
+ batchSize: 1000,
+ splitMaxMb: splitSqlOutput.value ? normalizedSplitSqlPartMaxMb() : undefined,
+ },
+ };
+ let destination: string;
+ try {
+ if (captured.allDatabases) {
+ const { open: openDialog } = await import("@tauri-apps/plugin-dialog");
+ const path = await openDialog({ directory: true, multiple: false, title: t("databaseExport.selectExportDirectory") });
+ if (typeof path !== "string") return;
+ destination = path;
+ } else {
+ const name = sanitizeFileName(databaseExportFileStem(captured.database || "database", captured.tables) || "database");
+ const path = await promptExportSavePath({ defaultFileName: `${name}.${captured.split ? "zip" : "sql"}`, filters: [{ name: captured.split ? "ZIP" : "SQL", extensions: [captured.split ? "zip" : "sql"] }] });
+ if (!path) return;
+ destination = path;
+ }
+ const { dirname } = await import("@tauri-apps/api/path");
+ await api.recordDatabaseExportDestination(captured.allDatabases ? destination : await dirname(destination));
+ } catch (error) {
+ toast(translateBackendError(t, error), 5000);
+ return;
+ }
+ const currentConfig = store.getConfig(captured.connectionId);
+ if (
+ disposed ||
+ !currentConfig ||
+ connectionId.value !== captured.connectionId ||
+ database.value !== captured.database ||
+ (isPostgresAllSchemas.value ? "" : schema.value) !== captured.schema ||
+ exportAllDatabases.value !== captured.allDatabases ||
+ connectionConfigFingerprint(currentConfig) !== captured.fingerprint ||
+ JSON.stringify(selectedTables.value) !== JSON.stringify(captured.tables) ||
+ JSON.stringify(selectedDatabases.value) !== JSON.stringify(captured.databases)
+ ) {
+ toast(t("exportProgress.connectionChanged"), 5000);
+ return;
+ }
+ const id = generateDatabaseExportId();
+ const label = captured.allDatabases ? t("databaseExport.allDatabasesTask", { count: captured.databases.length }) : captured.database || "database";
+ const task = addDatabaseExportTask(id, label, destination);
+ exportId.value = id;
+ exportFilePath.value = destination;
+ exportDone.value = false;
+ exportError.value = null;
+ exportWarning.value = null;
+ exportCancelled.value = false;
+ exportFinishedAt.value = null;
+ batchDatabaseIndex.value = 0;
+ batchDatabaseTotal.value = 0;
+ batchRowsExported.value = 0;
+ exportProgress.value = { exportId: id, currentObject: "", objectIndex: 0, totalObjects: 0, rowsExported: 0, totalRows: null, status: "Running", error: null, preparing: true };
+ const ownsView = () => !disposed && exportId.value === id;
+ const sync = () => {
+ if (!ownsView()) return;
+ desktopTaskStatus.value = task.status;
+ exportStartedAt.value = task.startedAt ?? null;
+ exportFinishedAt.value = task.finishedAt ?? null;
+ isExporting.value = task.status === "Queued" || task.status === "Running" || task.status === "Writing" || task.status === "Cancelling";
+ exportDone.value = task.status === "Done";
+ exportCancelled.value = task.status === "Cancelled";
+ exportError.value = task.status === "Unknown" || task.status === "Error" ? task.errorMessage || t("exportProgress.unknown") : null;
+ };
+ let completion: Promise<"settled" | "unknown"> | undefined;
+ const execute = async (): Promise<"settled" | "unknown"> => {
+ const controller = new AbortController();
+ let activeExport = "";
+ let unknown = false;
+ let rows = 0;
+ let completedItems = 0;
+ let totalItems = 0;
+ let lenientErrors = 0;
+ let firstError: string | null = null;
+ let firstFile = "";
+ let confirmedCancelled = false;
+ let lastProgress: ExportProgress | undefined;
+ const check = () => {
+ if (controller.signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ const current = store.getConfig(captured.connectionId);
+ if (!current || connectionConfigFingerprint(current) !== captured.fingerprint) throw new SnapshotCompletionError("failed", t("exportProgress.connectionChanged"));
+ };
+ exportTracker.registerTaskCancelHandler(id, async () => {
+ controller.abort();
+ task.status = "Cancelling";
+ sync();
+ if (activeExport) await api.cancelDatabaseExport(activeExport);
+ });
+ try {
+ check();
+ let plan: AllDatabaseExportPlanItem[];
+ if (captured.allDatabases) {
+ const schemaAware = isSchemaAware(captured.connectionType);
+ const schemasByDatabase: Record<string, string[]> = {};
+ if (schemaAware)
+ for (const database of captured.databases) {
+ check();
+ try {
+ schemasByDatabase[database] = filterExportableSchemas(await api.listSchemas(captured.connectionId, database), captured.connectionType);
+ } catch (error) {
+ throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ }
+ check();
+ }
+ plan = buildAllDatabaseExportPlan({ databases: captured.databases, schemaAware, schemasByDatabase, dbType: captured.connectionType });
+ } else plan = [{ database: captured.database, schema: captured.schema, displayName: label, fileStem: label }];
+ totalItems = plan.length;
+ if (ownsView()) batchDatabaseTotal.value = captured.allDatabases ? totalItems : 0;
+ for (const [index, item] of plan.entries()) {
+ check();
+ if (ownsView()) batchDatabaseIndex.value = index + 1;
+ const filePath = captured.allDatabases ? joinExportPath(destination, `${sanitizeFileName(item.fileStem)}.${captured.split ? "zip" : "sql"}`) : destination;
+ firstFile ||= filePath;
+ let itemRows = 0;
+ const currentId = captured.allDatabases ? `${id}-${index + 1}` : id;
+ const terminal = await runWithDatabaseBackupSnapshot({ connectionId: captured.connectionId, database: item.database, enabled: shouldUseDatabaseBackupSnapshot(captured.connectionType, captured.request.includeData, true), reportCompletion: true }, async (snapshotSessionId) => {
+ check();
+ activeExport = currentId;
+ try {
+ return await runDatabaseExportUntilTerminal(
+ { ...captured.request, selectedTables: captured.allDatabases ? undefined : captured.request.selectedTables, exportId: currentId, connectionId: captured.connectionId, database: item.database, schema: item.schema, filePath, snapshotSessionId },
+ (progress) => {
+ lastProgress = progress;
+ const nextRows = Math.max(0, progress.rowsExported);
+ rows += Math.max(0, nextRows - itemRows);
+ itemRows = nextRows;
+ const combined: ExportProgress = { ...progress, exportId: id, status: "Running", rowsExported: rows, ...(captured.allDatabases ? { currentObject: `${item.displayName}: ${progress.currentObject || item.displayName}`, objectIndex: index, totalObjects: plan.length } : {}) };
+ updateDatabaseExportTask(id, combined);
+ if (controller.signal.aborted) task.status = "Cancelling";
+ if (ownsView()) {
+ exportProgress.value = combined;
+ batchRowsExported.value = rows;
+ }
+ sync();
+ },
+ true,
+ );
+ } finally {
+ activeExport = "";
+ }
+ });
+ completedItems = index + 1;
+ lenientErrors += terminal.errorCount ?? 0;
+ firstError ??= terminal.errorSummary ?? null;
+ if (terminal.status === "Cancelled") {
+ confirmedCancelled = true;
+ controller.abort();
+ break;
+ }
+ }
+ const cancelled = confirmedCancelled || (controller.signal.aborted && completedItems < totalItems);
+ const final: ExportProgress = {
+ exportId: id,
+ currentObject: captured.allDatabases ? label : lastProgress?.currentObject || label,
+ objectIndex: captured.allDatabases ? completedItems : (lastProgress?.objectIndex ?? completedItems),
+ totalObjects: captured.allDatabases ? totalItems : (lastProgress?.totalObjects ?? totalItems),
+ rowsExported: rows,
+ totalRows: captured.allDatabases ? null : (lastProgress?.totalRows ?? null),
+ status: cancelled ? "Cancelled" : "Done",
+ error: null,
+ errorCount: lenientErrors,
+ errorSummary: firstError,
+ };
+ updateDatabaseExportTask(id, final);
+ if (ownsView()) {
+ exportProgress.value = final;
+ exportWarning.value = firstError;
+ }
+ if (!cancelled) {
+ if (captured.allDatabases)
+ notifyExportComplete({
+ filePath: firstFile || destination,
+ message: lenientErrors ? t("databaseExport.exportAllSuccessWithErrors", { count: captured.databases.length, errorCount: lenientErrors, firstError: firstError ?? "" }) : t("databaseExport.exportAllSuccess", { count: captured.databases.length }),
+ openFolderLabel: t("exportProgress.openFolder"),
+ toast,
+ duration: lenientErrors ? 8000 : 3000,
+ });
+ else toastDatabaseExportCompletion(lenientErrors, firstError, destination);
+ }
+ return "settled";
+ } catch (error) {
+ unknown = error instanceof SnapshotCompletionError && error.status === "unknown";
+ task.status = unknown ? "Unknown" : error instanceof SnapshotCompletionError && error.status === "cancelled" ? "Cancelled" : "Error";
+ task.errorMessage = error instanceof Error ? error.message : String(error);
+ task.finishedAt = unknown ? undefined : Date.now();
+ return unknown ? "unknown" : "settled";
+ } finally {
+ if (!unknown) exportTracker.unregisterTaskCancelHandler(id);
+ task.canCancel = false;
+ sync();
+ }
+ };
+ exportTracker.submitExportTask(task, captured.mode, () => (completion = execute()), sync);
+ if (captured.mode === "immediate") await completion;
+}
+
async function startExport() {
if (!canExport.value) return;
+ if (isTauriRuntime()) {
+ await startDesktopExport();
+ return;
+ }
if (exportAllDatabases.value) {
await startAllDatabasesExport();
return;
@@ -732,6 +966,10 @@ async function startAllDatabasesExport() {
}
async function cancelExport() {
+ if (isTauriRuntime() && desktopTaskStatus.value && exportId.value) {
+ await exportTracker.cancelTask(exportId.value);
+ return;
+ }
if (exportId.value) {
if (exportAllDatabases.value) {
exportCancelled.value = true;
@@ -747,6 +985,8 @@ async function cancelExport() {
}
function resetState() {
+ desktopTaskStatus.value = null;
+ executionMode.value = "immediate";
connectionId.value = "";
database.value = "";
databases.value = [];
@@ -791,6 +1031,7 @@ const progressPercent = computed(() => {
/** True while schema metadata is still loading — before objects are written. */
const isPreparingExport = computed(() => {
+ if (desktopTaskStatus.value === "Queued") return false;
if (!isExporting.value) return false;
if (exportDone.value || exportError.value || exportCancelled.value) return false;
const p = exportProgress.value;
@@ -799,6 +1040,8 @@ const isPreparingExport = computed(() => {
});
const progressStatusText = computed(() => {
+ if (desktopTaskStatus.value === "Queued") return t("exportProgress.queued");
+ if (desktopTaskStatus.value === "Cancelling") return t("databaseBackup.cancelling");
const p = exportProgress.value;
if (isPreparingExport.value) {
// Keep it as presence feedback only — no second progress counter that later resets.
@@ -1105,6 +1348,7 @@ watch([includeStructure, includeData, insertDialect, insertMode, includeObjects,
<p v-if="splitSqlOutput" class="pl-5 text-[11px] text-muted-foreground">
{{ t("databaseExport.splitSqlOutputDescription", { min: MIN_SPLIT_SQL_PART_MB, max: MAX_SPLIT_SQL_PART_MB }) }}
</p>
+ <ExportExecutionMode v-if="isTauriRuntime()" v-model="executionMode" />
</div>
</div>
@@ -1115,16 +1359,16 @@ watch([includeStructure, includeData, insertDialect, insertMode, includeObjects,
</div>
<div class="space-y-2">
<div v-if="!exportAllDatabases || !exportDone" class="flex items-center gap-2 text-xs text-muted-foreground">
- <Loader2 v-if="isExporting && !exportDone && !exportError && !exportCancelled" class="h-3.5 w-3.5 shrink-0 animate-spin text-primary" />
+ <Loader2 v-if="isExporting && desktopTaskStatus !== 'Queued' && !exportDone && !exportError && !exportCancelled" class="h-3.5 w-3.5 shrink-0 animate-spin text-primary" />
<span>{{ progressStatusText }}</span>
</div>
- <div class="w-full bg-muted rounded-full h-2 overflow-hidden">
+ <div v-if="desktopTaskStatus !== 'Queued'" class="w-full bg-muted rounded-full h-2 overflow-hidden">
<div v-if="isPreparingExport" class="database-export-progress-indeterminate h-full rounded-full bg-primary" />
<div v-else class="h-full rounded-full transition-[width] duration-300" :class="exportError ? 'bg-destructive' : exportCancelled ? 'bg-yellow-500' : exportDone ? 'bg-green-500' : 'bg-primary'" :style="{ width: `${exportDone ? 100 : progressPercent}%` }" />
</div>
- <div v-if="exportProgress && !isPreparingExport" class="text-xs text-muted-foreground tabular-nums">
+ <div v-if="exportProgress && desktopTaskStatus !== 'Queued' && !isPreparingExport" class="text-xs text-muted-foreground tabular-nums">
{{ exportAllDatabases ? t("databaseExport.allRowsExported", { count: exportProgress.rowsExported.toLocaleString() }) : t("databaseExport.rowsExported", { current: exportProgress.objectIndex, total: exportProgress.totalObjects, count: exportProgress.rowsExported.toLocaleString() }) }}
</div>
<div v-if="exportElapsedText" class="text-xs text-muted-foreground tabular-nums">
@@ -1168,7 +1412,7 @@ watch([includeStructure, includeData, insertDialect, insertMode, includeObjects,
<Button variant="outline" size="sm" @click="open = false">
{{ t("databaseExport.runInBackground") }}
</Button>
- <Button variant="destructive" size="sm" @click="cancelExport">
+ <Button variant="destructive" size="sm" :disabled="desktopTaskStatus === 'Cancelling'" @click="cancelExport">
<X class="w-3.5 h-3.5 mr-1.5" />
{{ t("transfer.cancel") }}
</Button>
diff --git a/apps/desktop/src/components/export/ExportExecutionMode.vue b/apps/desktop/src/components/export/ExportExecutionMode.vue
new file mode 100644
index 0000000000..0155c04bb5
--- /dev/null
+++ b/apps/desktop/src/components/export/ExportExecutionMode.vue
@@ -0,0 +1,26 @@
+<script setup lang="ts">
+import { useId } from "vue";
+import { useI18n } from "vue-i18n";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
+
+const { t } = useI18n();
+const id = useId();
+const mode = defineModel<ManualExportMode>({ default: "immediate" });
+</script>
+
+<template>
+ <fieldset class="space-y-2">
+ <legend class="text-sm font-medium">{{ t("exportProgress.executionMode") }}</legend>
+ <div class="flex flex-wrap gap-x-5 gap-y-2">
+ <label class="flex cursor-pointer items-center gap-2 text-sm">
+ <input v-model="mode" type="radio" :name="id" value="immediate" class="h-4 w-4" />
+ {{ t("exportProgress.immediate") }}
+ </label>
+ <label class="flex cursor-pointer items-center gap-2 text-sm">
+ <input v-model="mode" type="radio" :name="id" value="queued" class="h-4 w-4" />
+ {{ t("exportProgress.queue") }}
+ </label>
+ </div>
+ <p class="text-xs text-muted-foreground">{{ t("exportProgress.executionModeHint") }}</p>
+ </fieldset>
+</template>
diff --git a/apps/desktop/src/components/export/ExportExecutionModeDialog.vue b/apps/desktop/src/components/export/ExportExecutionModeDialog.vue
new file mode 100644
index 0000000000..2d381b850e
--- /dev/null
+++ b/apps/desktop/src/components/export/ExportExecutionModeDialog.vue
@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import { ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import ExportExecutionMode from "./ExportExecutionMode.vue";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
+
+const { t } = useI18n();
+const mode = ref<ManualExportMode>("immediate");
+const open = defineModel<boolean>("open", { default: true });
+const emit = defineEmits<{ confirm: [mode: ManualExportMode]; cancel: [] }>();
+</script>
+
+<template>
+ <Dialog
+ v-model:open="open"
+ @update:open="
+ (value) => {
+ if (!value) emit('cancel');
+ }
+ "
+ >
+ <DialogContent class="sm:max-w-sm" @interact-outside.prevent>
+ <DialogHeader>
+ <DialogTitle>{{ t("grid.export") }}</DialogTitle>
+ </DialogHeader>
+ <ExportExecutionMode v-model="mode" class="py-3" />
+ <DialogFooter>
+ <Button variant="outline" @click="emit('cancel')">{{ t("common.cancel") }}</Button>
+ <Button @click="emit('confirm', mode)">{{ t("common.confirm") }}</Button>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
+</template>
diff --git a/apps/desktop/src/components/export/ExportProgressDialog.vue b/apps/desktop/src/components/export/ExportProgressDialog.vue
index b129e41697..47423e0d27 100644
--- a/apps/desktop/src/components/export/ExportProgressDialog.vue
+++ b/apps/desktop/src/components/export/ExportProgressDialog.vue
@@ -3,7 +3,7 @@ import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
import { useI18n } from "vue-i18n";
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
import { Button } from "@/components/ui/button";
-import { Loader2, CheckCircle2, XCircle, AlertCircle, FolderOpen, Minimize2, Wrench, X } from "@lucide/vue";
+import { Loader2, CheckCircle2, XCircle, AlertCircle, Clock, FolderOpen, Minimize2, Wrench, X } from "@lucide/vue";
import { useToast } from "@/composables/useToast";
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
import { autoRevealExportedPathIfConfigured, revealExportedPath } from "@/lib/export/exportPath";
@@ -60,7 +60,7 @@ const displayName = computed(() => {
}
return `${props.tableName} (.${props.format})`;
});
-const isActive = computed(() => props.status === "Running" || props.status === "Writing");
+const isActive = computed(() => props.status === "Queued" || props.status === "Running" || props.status === "Writing" || props.status === "Cancelling");
const isFinished = computed(() => props.status === "Done" || props.status === "Error" || props.status === "Cancelled");
const canChangeQueryTimeout = computed(() => props.status === "Error" && !!props.connectionId && !!props.errorMessage && isQueryTimeoutErrorMessage(props.errorMessage));
const canRevealFile = computed(() => props.status === "Done" && !!props.filePath && isTauriRuntime());
@@ -113,7 +113,7 @@ watch(
}
"
>
- <DialogContent class="sm:max-w-md" :class="{ 'pointer-events-none': isActive }" @interact-outside.prevent>
+ <DialogContent class="sm:max-w-md" :show-close-button="!isActive" @interact-outside.prevent>
<DialogHeader>
<DialogTitle>{{ title }}</DialogTitle>
</DialogHeader>
@@ -135,7 +135,19 @@ watch(
<!-- Status message -->
<div class="flex items-center gap-2 text-sm">
- <template v-if="status === 'Running'">
+ <template v-if="status === 'Queued'">
+ <Clock class="h-4 w-4 text-muted-foreground" />
+ <span>{{ t("exportProgress.queued") }}</span>
+ </template>
+ <template v-else-if="status === 'Unknown'">
+ <AlertCircle class="h-4 w-4 text-yellow-500" />
+ <span>{{ t("exportProgress.unknown") }}</span>
+ </template>
+ <template v-else-if="status === 'Cancelling'">
+ <Loader2 class="h-4 w-4 animate-spin text-primary" />
+ <span>{{ t("databaseBackup.cancelling") }}</span>
+ </template>
+ <template v-else-if="status === 'Running'">
<Loader2 class="h-4 w-4 animate-spin text-primary" />
<span>{{ t("exportProgress.fetching") }}</span>
</template>
@@ -158,7 +170,7 @@ watch(
</div>
<!-- Row count -->
- <div class="text-xs text-muted-foreground tabular-nums">
+ <div v-if="status !== 'Queued'" class="text-xs text-muted-foreground tabular-nums">
{{ rowsText }}
<span v-if="elapsedText" class="ml-2">{{ t("exportProgress.elapsed", { duration: elapsedText }) }}</span>
</div>
@@ -170,12 +182,12 @@ watch(
<Minimize2 class="h-3.5 w-3.5 mr-1" />
{{ t("exportProgress.minimize") }}
</Button>
- <Button variant="outline" size="sm" :disabled="disableCancel" @click="emit('cancel')">
+ <Button variant="outline" size="sm" :disabled="disableCancel || status === 'Cancelling'" @click="emit('cancel')">
<X class="h-3.5 w-3.5 mr-1" />
{{ t("exportProgress.cancel") }}
</Button>
</template>
- <template v-else-if="isFinished">
+ <template v-else-if="isFinished || status === 'Unknown'">
<Button v-if="canChangeQueryTimeout" variant="outline" size="sm" @click="emit('changeQueryTimeout')">
<Wrench class="mr-1 h-3.5 w-3.5" />
{{ t("editor.changeQueryTimeout") }}
diff --git a/apps/desktop/src/components/export/ExportProgressPopover.vue b/apps/desktop/src/components/export/ExportProgressPopover.vue
index fc7a03f88c..a422e79bc6 100644
--- a/apps/desktop/src/components/export/ExportProgressPopover.vue
+++ b/apps/desktop/src/components/export/ExportProgressPopover.vue
@@ -3,7 +3,7 @@ import { computed, onBeforeUnmount, onMounted, ref } from "vue";
import { useI18n } from "vue-i18n";
import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
import { Button } from "@/components/ui/button";
-import { Loader2, Check, CheckCircle2, XCircle, AlertCircle, X, FileDown, Database, DatabaseBackup, FileCode2, ArrowRightLeft, Layers3, GitCompareArrows, ChevronRight, FolderOpen, Copy } from "@lucide/vue";
+import { Loader2, Check, CheckCircle2, XCircle, AlertCircle, Clock, X, FileDown, Database, DatabaseBackup, FileCode2, ArrowRightLeft, Layers3, GitCompareArrows, ChevronRight, FolderOpen, Copy } from "@lucide/vue";
import { formatDataTransferDuration, useExportTracker, type ExportTask } from "@/composables/useExportTracker";
import { dataTransferFailureCopyText } from "@/components/export/failureDetailCopyText";
import SqlFileProgressIndicator from "@/components/sql-file/SqlFileProgressIndicator.vue";
@@ -212,6 +212,8 @@ const rowsText = (task: ExportTask) => {
};
const taskStatusText = (task: ExportTask) => {
+ if (task.status === "Queued") return t("exportProgress.queued");
+ if (task.status === "Unknown") return t("exportProgress.unknown");
if (task.status === "Cancelling") return t("databaseBackup.cancelling");
if (task.kind !== "schema-diff" && task.kind !== "data-compare") return "";
if (task.status === "Running") return t("exportProgress.compareRunning");
@@ -249,6 +251,10 @@ const statusIcon = (task: ExportTask) => {
if (task.kind === "schema-diff" || task.kind === "data-compare") return GitCompareArrows;
}
switch (task.status) {
+ case "Queued":
+ return Clock;
+ case "Unknown":
+ return AlertCircle;
case "Running":
case "Writing":
case "Cancelling":
@@ -316,7 +322,7 @@ function failureDetailCount(task: ExportTask) {
}
function hasUnlistedTaskError(task: ExportTask) {
- if (task.status !== "Error" || !task.errorMessage) return false;
+ if ((task.status !== "Error" && task.status !== "Unknown") || !task.errorMessage) return false;
if (task.kind === "sql-file") return !(task.sqlFileFailures ?? []).some((failure) => failure.error === task.errorMessage);
if (task.kind === "data-transfer") return !(task.transferFailures ?? []).some((failure) => failure.error === task.errorMessage);
return true;
@@ -402,7 +408,7 @@ function openTask(task: ExportTask): void {
</div>
<div class="min-w-0 text-muted-foreground">
- <span class="break-words tabular-nums">{{ rowsText(task) }}</span>
+ <span v-if="task.status !== 'Queued'" class="break-words tabular-nums">{{ rowsText(task) }}</span>
<span v-if="task.kind === 'sql-file' && task.elapsedMs !== undefined" class="ml-1 tabular-nums">{{ t("exportProgress.elapsed", { duration: formatDataTransferDuration(task.elapsedMs) }) }}</span>
<span v-if="task.kind !== 'data-transfer' && task.startedAt !== undefined" class="ml-1 tabular-nums">{{ elapsedText(task) }}</span>
<span v-if="taskStatusText(task)" class="ml-1 font-medium text-primary">{{ taskStatusText(task) }}</span>
@@ -455,7 +461,7 @@ function openTask(task: ExportTask): void {
<FolderOpen class="h-3.5 w-3.5 text-muted-foreground hover:text-foreground" />
</button>
<button
- v-if="isActive(task.status) && task.canCancel !== false"
+ v-if="(isActive(task.status) || task.status === 'Queued') && task.canCancel !== false"
class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted disabled:cursor-not-allowed"
:disabled="task.status === 'Cancelling'"
:title="task.status === 'Cancelling' ? t('databaseBackup.cancelling') : t('exportProgress.cancel')"
@@ -464,7 +470,7 @@ function openTask(task: ExportTask): void {
<Loader2 v-if="task.status === 'Cancelling'" class="h-3.5 w-3.5 animate-spin text-primary" />
<X v-else class="h-3.5 w-3.5 text-muted-foreground hover:text-destructive" />
</button>
- <button v-else-if="!isActive(task.status)" class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.delete')" @click="removeTask(task.exportId)">
+ <button v-else-if="isFinished(task.status) || task.status === 'Unknown'" class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.delete')" @click="removeTask(task.exportId)">
<X class="h-3.5 w-3.5 text-muted-foreground hover:text-foreground" />
</button>
</div>
diff --git a/apps/desktop/src/components/export/SqlInsertModeDialog.vue b/apps/desktop/src/components/export/SqlInsertModeDialog.vue
index 9ad721023f..ae1bb9ebaa 100644
--- a/apps/desktop/src/components/export/SqlInsertModeDialog.vue
+++ b/apps/desktop/src/components/export/SqlInsertModeDialog.vue
@@ -4,11 +4,14 @@ import { useI18n } from "vue-i18n";
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
import { Button } from "@/components/ui/button";
import type { SqlExportColumnSelection, SqlExportOptions, SqlInsertMode } from "@/lib/export/sqlInsertMode";
+import ExportExecutionMode from "./ExportExecutionMode.vue";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
const { t } = useI18n();
const open = defineModel<boolean>("open", { default: false });
-const props = defineProps<{ allowSplit?: boolean; columns?: SqlExportColumnSelection[] }>();
+const props = defineProps<{ allowSplit?: boolean; columns?: SqlExportColumnSelection[]; showExecutionMode?: boolean }>();
const selected = ref<SqlInsertMode>("batch");
+const executionMode = ref<ManualExportMode>("immediate");
const selectedColumnIndexes = ref(props.columns?.map((column) => column.sourceIndex) ?? []);
const splitSqlOutput = ref(false);
const splitSqlPartMaxMb = ref(100);
@@ -44,6 +47,7 @@ function onConfirm() {
insertMode: selected.value,
splitMaxMb: props.allowSplit && splitSqlOutput.value ? normalizedSplitSqlPartMaxMb() : undefined,
...(columnSelectionEnabled.value ? { selectedColumns: selectedColumns.value } : {}),
+ ...(props.showExecutionMode ? { executionMode: executionMode.value } : {}),
});
}
@@ -69,11 +73,11 @@ function onOpenChange(value: boolean) {
<template>
<Dialog v-model:open="open" @update:open="onOpenChange">
- <DialogContent class="sm:max-w-md" @interact-outside.prevent>
+ <DialogContent class="grid-rows-[auto_minmax(0,1fr)_auto] sm:max-w-md" @interact-outside.prevent>
<DialogHeader>
<DialogTitle>{{ t("grid.sqlInsertModeTitle") }}</DialogTitle>
</DialogHeader>
- <div class="space-y-3 py-2">
+ <div class="min-h-0 space-y-3 overflow-y-auto py-2">
<p class="text-sm text-muted-foreground">{{ t("grid.sqlInsertModePrompt") }}</p>
<label class="flex cursor-pointer items-start gap-3 rounded-md border p-3 transition-colors hover:bg-accent/50">
<input v-model="selected" type="radio" value="batch" class="mt-0.5 h-4 w-4 shrink-0" data-sql-insert-mode="batch" />
@@ -123,6 +127,7 @@ function onOpenChange(value: boolean) {
{{ t("databaseExport.splitSqlOutputDescription", { min: MIN_SPLIT_SQL_PART_MB, max: MAX_SPLIT_SQL_PART_MB }) }}
</p>
</div>
+ <ExportExecutionMode v-if="props.showExecutionMode" v-model="executionMode" />
</div>
<DialogFooter>
<Button variant="outline" @click="onCancel">{{ t("common.cancel") }}</Button>
diff --git a/apps/desktop/src/components/export/XlsxHeaderDialog.vue b/apps/desktop/src/components/export/XlsxHeaderDialog.vue
index b6f7f76d0f..1555a2f0aa 100644
--- a/apps/desktop/src/components/export/XlsxHeaderDialog.vue
+++ b/apps/desktop/src/components/export/XlsxHeaderDialog.vue
@@ -4,15 +4,18 @@ import { useI18n } from "vue-i18n";
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
import { Button } from "@/components/ui/button";
import type { XlsxExportOptions, XlsxHeaderMode } from "@/lib/export/xlsxHeader";
+import ExportExecutionMode from "./ExportExecutionMode.vue";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
const { t } = useI18n();
-const props = withDefaults(defineProps<{ showHeaderOptions?: boolean }>(), {
+const props = withDefaults(defineProps<{ showHeaderOptions?: boolean; showExecutionMode?: boolean }>(), {
showHeaderOptions: true,
});
const open = defineModel<boolean>("open", { default: false });
const selected = ref<XlsxHeaderMode>("name");
const autoFilter = ref(false);
+const executionMode = ref<ManualExportMode>("immediate");
const emit = defineEmits<{
confirm: [options: XlsxExportOptions];
@@ -21,7 +24,7 @@ const emit = defineEmits<{
function onConfirm() {
open.value = false;
- emit("confirm", { headerMode: selected.value, autoFilter: autoFilter.value });
+ emit("confirm", { headerMode: selected.value, autoFilter: autoFilter.value, ...(props.showExecutionMode ? { executionMode: executionMode.value } : {}) });
}
function onCancel() {
@@ -70,6 +73,7 @@ function onOpenChange(value: boolean) {
<span class="text-sm">{{ t("grid.xlsxIncludeAutoFilter") }}</span>
</label>
</div>
+ <ExportExecutionMode v-if="props.showExecutionMode" v-model="executionMode" />
</div>
<DialogFooter>
<Button variant="outline" @click="onCancel">{{ t("common.cancel") }}</Button>
diff --git a/apps/desktop/src/components/export/__tests__/DatabaseExportDialog.queue.spec.ts b/apps/desktop/src/components/export/__tests__/DatabaseExportDialog.queue.spec.ts
new file mode 100644
index 0000000000..a7de0b1338
--- /dev/null
+++ b/apps/desktop/src/components/export/__tests__/DatabaseExportDialog.queue.spec.ts
@@ -0,0 +1,209 @@
+// @vitest-environment happy-dom
+import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import DatabaseExportDialog from "../DatabaseExportDialog.vue";
+import { useExportTracker } from "@/composables/useExportTracker";
+import type { ConnectionConfig } from "@/types/database";
+import type { DatabaseExportRequest, ExportProgress } from "@/lib/backend/api";
+
+const mocks = vi.hoisted(() => ({ export: vi.fn(), begin: vi.fn(), rollback: vi.fn(), cancel: vi.fn(), toast: vi.fn(), listSchemas: vi.fn() }));
+vi.mock("@/lib/backend/api", () => ({
+ listDatabases: vi.fn(async () => [{ name: "app" }, { name: "other" }]),
+ listSchemas: mocks.listSchemas,
+ listTables: vi.fn(async () => [
+ { name: "orders", table_type: "TABLE" },
+ { name: "audit", table_type: "TABLE" },
+ ]),
+ exportDatabaseSql: mocks.export,
+ beginDatabaseBackupSnapshot: mocks.begin,
+ rollbackManualTransaction: mocks.rollback,
+ cancelDatabaseExport: mocks.cancel,
+ recordDatabaseExportDestination: vi.fn(async () => undefined),
+}));
+vi.mock("@/stores/connectionStore", () => ({ useConnectionStore: () => ({ connections: [connection], getConfig: () => connection, ensureConnected: vi.fn(async () => undefined) }) }));
+vi.mock("@/stores/settingsStore", () => ({ useSettingsStore: () => ({ editorSettings: {} }) }));
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => true }));
+vi.mock("@/lib/export/exportPath", () => ({ promptExportSavePath: vi.fn(async () => "C:/exports/original.sql"), autoRevealExportedPathIfConfigured: vi.fn() }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn(async () => "C:/exports") }));
+vi.mock("@tauri-apps/api/path", () => ({ dirname: vi.fn(async () => "C:/exports") }));
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+vi.mock("@/i18n", () => ({ default: { install() {}, global: { t: (key: string) => key } } }));
+vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
+vi.mock("@/components/icons/DatabaseIcon.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/connection/ConnectionGroupBadge.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/ui/dialog", () => {
+ const component = defineComponent({
+ setup:
+ (_, { slots }) =>
+ () =>
+ h("div", slots.default?.()),
+ });
+ return { Dialog: component, DialogHeader: component, DialogTitle: component, DialogFooter: component, DialogContent: component };
+});
+vi.mock("@/components/ui/select", () => {
+ const component = defineComponent({
+ setup:
+ (_, { slots }) =>
+ () =>
+ h("div", slots.default?.()),
+ });
+ return { Select: component, SelectContent: component, SelectItem: component, SelectTrigger: component, SelectValue: component };
+});
+
+const connection = { id: "database-export-queue", name: "MySQL", db_type: "mysql", database: "app", transport_layers: [] } as unknown as ConnectionConfig;
+const operations: Array<{ request: DatabaseExportRequest; progress: (value: ExportProgress) => void; resolve: () => void; reject: (error: Error) => void }> = [];
+const mounted: Array<{ app: App; host: HTMLElement }> = [];
+beforeEach(() => {
+ vi.clearAllMocks();
+ localStorage.clear();
+ operations.length = 0;
+ connection.db_type = "mysql";
+ mocks.listSchemas.mockResolvedValue(["public"]);
+ mocks.begin.mockReset().mockImplementation(async (_id, database) => ({ sessionId: `snapshot-${database}` }));
+ mocks.rollback.mockReset().mockResolvedValue(undefined);
+ mocks.cancel.mockResolvedValue(undefined);
+ mocks.export.mockImplementation((request, progress) => new Promise<void>((resolve, reject) => operations.push({ request, progress, resolve, reject })));
+});
+afterEach(() => {
+ for (const { app, host } of mounted.splice(0)) {
+ app.unmount();
+ host.remove();
+ }
+ const tracker = useExportTracker();
+ for (const task of tracker.tasks.value) tracker.removeTask(task.exportId);
+});
+async function mountDialog(allDatabases = false) {
+ const host = document.createElement("div");
+ document.body.append(host);
+ const open = ref(true);
+ const app = createApp({
+ setup: () => () =>
+ h(DatabaseExportDialog, {
+ open: open.value,
+ "onUpdate:open": (value: boolean) => {
+ open.value = value;
+ },
+ prefillConnectionId: connection.id,
+ ...(allDatabases ? { prefillAllDatabases: true } : { prefillDatabase: "app", prefillSchema: "app", prefillTable: "orders" }),
+ }),
+ });
+ mounted.push({ app, host });
+ app.mount(host);
+ const key = allDatabases ? "databaseExport.exportAllDatabases" : "databaseExport.export";
+ const button = await vi.waitFor(() => {
+ const button = [...host.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.trim() === key);
+ expect(button).toBeDefined();
+ expect(button!.disabled).toBe(false);
+ return button!;
+ });
+ return {
+ host,
+ open,
+ start: async () => {
+ const radio = host.querySelector<HTMLInputElement>('input[value="queued"]')!;
+ radio.checked = true;
+ radio.dispatchEvent(new Event("change", { bubbles: true }));
+ await nextTick();
+ button.click();
+ await vi.waitFor(() => expect(useExportTracker().tasks.value.some((task) => task.kind === "database-export")).toBe(true));
+ },
+ };
+}
+function terminal(index: number, status: "Done" | "Cancelled" = "Done", resolve = true) {
+ const operation = operations[index]!;
+ operation.progress({ exportId: operation.request.exportId, currentObject: "orders", objectIndex: 1, totalObjects: 1, rowsExported: 7, totalRows: 7, status, error: null });
+ if (resolve) operation.resolve();
+}
+it("does not begin a snapshot or database export while queued and cancels waiting without RPCs", async () => {
+ const tracker = useExportTracker();
+ let release!: () => void;
+ tracker.submitExportTask(
+ tracker.addTask("blocker", "csv", "first.csv"),
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ const dialog = await mountDialog();
+ await dialog.start();
+ expect(dialog.host.textContent).toContain("exportProgress.queued");
+ expect(mocks.begin).not.toHaveBeenCalled();
+ expect(mocks.export).not.toHaveBeenCalled();
+ await tracker.cancelTask(tracker.tasks.value[1]!.exportId);
+ release();
+ await nextTick();
+ expect(mocks.cancel).not.toHaveBeenCalled();
+ expect(mocks.begin).not.toHaveBeenCalled();
+});
+it("keeps a single database lease through native completion and snapshot rollback", async () => {
+ const tracker = useExportTracker();
+ const dialog = await mountDialog();
+ await dialog.start();
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ let rollback!: () => void;
+ mocks.rollback.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ rollback = resolve;
+ }),
+ );
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ terminal(0, "Done", false);
+ expect(next).not.toHaveBeenCalled();
+ expect(mocks.rollback).not.toHaveBeenCalled();
+ operations[0]!.resolve();
+ await vi.waitFor(() => expect(mocks.rollback).toHaveBeenCalledOnce());
+ expect(tracker.tasks.value[0]!.status).toBe("Running");
+ expect(next).not.toHaveBeenCalled();
+ rollback();
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ expect(tracker.tasks.value[0]!.status).toBe("Done");
+ expect(operations[0]!.request).toMatchObject({ database: "app", selectedTables: ["orders"], snapshotSessionId: "snapshot-app", filePath: "C:/exports/original.sql" });
+});
+it("holds the whole multi-database operation across child completion and each rollback", async () => {
+ const tracker = useExportTracker();
+ const dialog = await mountDialog(true);
+ await dialog.start();
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ terminal(0);
+ await vi.waitFor(() => expect(operations).toHaveLength(2));
+ expect(next).not.toHaveBeenCalled();
+ expect(mocks.rollback).toHaveBeenCalledWith("snapshot-app");
+ expect(operations.map((operation) => operation.request.filePath)).toEqual(["C:/exports/app.sql", "C:/exports/other.sql"]);
+ terminal(1);
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ expect(mocks.rollback).toHaveBeenCalledWith("snapshot-other");
+});
+it.each([false, true])("waits through cancellation and rollback without starting another database (batch: %s)", async (batch) => {
+ const tracker = useExportTracker();
+ const dialog = await mountDialog(batch);
+ await dialog.start();
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(mocks.cancel).toHaveBeenCalledWith(operations[0]!.request.exportId);
+ expect(next).not.toHaveBeenCalled();
+ terminal(0, "Cancelled");
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ expect(operations).toHaveLength(1);
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelled");
+ expect(mocks.rollback).toHaveBeenCalledOnce();
+});
+it("does not release the queue when rollback completion is unknown", async () => {
+ const tracker = useExportTracker();
+ const dialog = await mountDialog();
+ await dialog.start();
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ mocks.rollback.mockRejectedValueOnce(new Error("rollback reply lost"));
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ terminal(0);
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe("Unknown"));
+ expect(next).not.toHaveBeenCalled();
+ expect(tracker.tasks.value[0]!.errorMessage).toBe("rollback reply lost");
+});
diff --git a/apps/desktop/src/components/export/__tests__/ExportProgressDialog.spec.ts b/apps/desktop/src/components/export/__tests__/ExportProgressDialog.spec.ts
index 66c5e2b8ed..7973ed6abd 100644
--- a/apps/desktop/src/components/export/__tests__/ExportProgressDialog.spec.ts
+++ b/apps/desktop/src/components/export/__tests__/ExportProgressDialog.spec.ts
@@ -106,3 +106,32 @@ describe("ExportProgressDialog query timeout action", () => {
expect(document.body.textContent).not.toContain("Change query timeout");
});
});
+
+describe("ExportProgressDialog queued states", () => {
+ it("lets the user cancel or minimize a waiting export without showing active progress", async () => {
+ i18n.global.locale.value = "en";
+ const onCancel = vi.fn();
+ const onMinimize = vi.fn();
+ await mountDialog({ ...baseProps, status: "Queued", startedAt: undefined, canMinimize: true, onCancel, onMinimize });
+ expect(document.body.textContent).toContain("Queued");
+ expect(document.body.textContent).not.toContain("Elapsed:");
+ expect(document.body.querySelector(".export-progress-indeterminate")).toBeNull();
+ const buttons = [...document.body.querySelectorAll("button")];
+ buttons.find((button) => button.textContent?.trim() === "Cancel")?.click();
+ buttons.find((button) => button.textContent?.trim() === i18n.global.t("exportProgress.minimize"))?.click();
+ expect(onCancel).toHaveBeenCalledOnce();
+ expect(onMinimize).toHaveBeenCalledOnce();
+ });
+
+ it("keeps an unknown export distinct from completion and allows closing its view", async () => {
+ i18n.global.locale.value = "en";
+ const onOpenChange = vi.fn();
+ await mountDialog({ ...baseProps, status: "Unknown", "onUpdate:open": onOpenChange });
+ expect(document.body.textContent).toContain("Export status unknown; the queue is blocked");
+ expect(document.body.textContent).not.toContain("Export completed!");
+ const close = [...document.body.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Close");
+ expect(close).toBeTruthy();
+ close?.click();
+ expect(onOpenChange).toHaveBeenCalledWith(false);
+ });
+});
diff --git a/apps/desktop/src/components/export/__tests__/ExportProgressPopover.spec.ts b/apps/desktop/src/components/export/__tests__/ExportProgressPopover.spec.ts
index d0f20a80ae..35c8222366 100644
--- a/apps/desktop/src/components/export/__tests__/ExportProgressPopover.spec.ts
+++ b/apps/desktop/src/components/export/__tests__/ExportProgressPopover.spec.ts
@@ -631,6 +631,47 @@ describe("ExportProgressPopover task duration", () => {
});
describe("ExportProgressPopover file name and reveal action", () => {
+ it("shows a queued saved file without running progress and cancels it from the task row", async () => {
+ const tracker = useExportTracker();
+ let finish!: (outcome: "settled") => void;
+ tracker.submitExportTask(
+ tracker.addTask("first", "csv", "/tmp/first.csv"),
+ "queued",
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const waiting = tracker.addTask("Query Result", "csv", "/tmp/waiting.csv");
+ const run = vi.fn(async () => "settled" as const);
+ tracker.submitExportTask(waiting, "queued", run);
+
+ await mountPopover();
+ const title = Array.from(document.body.querySelectorAll("span")).find((node) => node.textContent === "waiting.csv");
+ const row = title?.closest("div.flex.items-start");
+ expect(row?.textContent).toContain("Queued");
+ expect(row?.textContent).not.toContain("Elapsed:");
+ expect(row?.querySelector(".export-progress-indeterminate")).toBeNull();
+ row?.querySelector<HTMLButtonElement>('button[title="Cancel"]')?.click();
+ await nextTick();
+ expect(waiting.status).toBe("Cancelled");
+ finish("settled");
+ await Promise.resolve();
+ expect(run).not.toHaveBeenCalled();
+ });
+
+ it("does not offer deletion or animate progress for an unknown export", async () => {
+ const tracker = useExportTracker();
+ const task = tracker.addTask("Query Result", "csv", "/tmp/unknown.csv");
+ task.status = "Unknown";
+ task.errorMessage = "transport interrupted";
+ await mountPopover();
+ expect(document.body.textContent).toContain("Export status unknown; the queue is blocked");
+ expect(document.body.textContent).toContain("transport interrupted");
+ expect(document.body.querySelector('button[title="Delete"]')).toBeNull();
+ expect(document.body.querySelector(".export-progress-indeterminate")).toBeNull();
+ });
+
it("shows the saved file name instead of the synthetic query-result label", async () => {
const tracker = useExportTracker();
tracker.addTask("Query Result", "sql", "C:\\exports\\自定义.sql");
diff --git a/apps/desktop/src/components/export/__tests__/SqlInsertModeDialog.spec.ts b/apps/desktop/src/components/export/__tests__/SqlInsertModeDialog.spec.ts
index 22614036bb..50efc25a8d 100644
--- a/apps/desktop/src/components/export/__tests__/SqlInsertModeDialog.spec.ts
+++ b/apps/desktop/src/components/export/__tests__/SqlInsertModeDialog.spec.ts
@@ -39,13 +39,13 @@ afterEach(() => {
i18n.global.locale.value = "en";
});
-async function mountDialog(onConfirm = () => {}, onCancel = () => {}, allowSplit = false, columns?: SqlExportColumnSelection[]) {
+async function mountDialog(onConfirm = () => {}, onCancel = () => {}, allowSplit = false, columns?: SqlExportColumnSelection[], showExecutionMode = false) {
const container = document.createElement("div");
document.body.appendChild(container);
const app = createApp(
defineComponent({
setup() {
- return () => h(SqlInsertModeDialog, { open: true, allowSplit, columns, onConfirm, onCancel });
+ return () => h(SqlInsertModeDialog, { open: true, allowSplit, columns, showExecutionMode, onConfirm, onCancel });
},
}),
);
@@ -56,6 +56,16 @@ async function mountDialog(onConfirm = () => {}, onCancel = () => {}, allowSplit
}
describe("SqlInsertModeDialog", () => {
+ it("confirms the SQL mode and queued execution together without changing the immediate default", async () => {
+ const onConfirm = vi.fn();
+ await mountDialog(onConfirm, () => {}, false, undefined, true);
+ expect(document.querySelector<HTMLInputElement>('input[value="immediate"]')!.checked).toBe(true);
+ document.querySelector<HTMLInputElement>('input[value="queued"]')!.click();
+ document.querySelector<HTMLInputElement>('[data-sql-insert-mode="single"]')!.click();
+ await nextTick();
+ document.querySelector<HTMLButtonElement>("[data-sql-insert-mode-confirm]")!.click();
+ expect(onConfirm).toHaveBeenCalledWith({ insertMode: "single", splitMaxMb: undefined, executionMode: "queued" });
+ });
it("defaults to every column and allows deselecting one duplicate independently", async () => {
const onConfirm = vi.fn();
const choices = sqlExportColumnChoices(["id", "name", "id"]);
diff --git a/apps/desktop/src/components/export/__tests__/XlsxHeaderDialog.spec.ts b/apps/desktop/src/components/export/__tests__/XlsxHeaderDialog.spec.ts
index f6fa04bf1a..af72fa54dd 100644
--- a/apps/desktop/src/components/export/__tests__/XlsxHeaderDialog.spec.ts
+++ b/apps/desktop/src/components/export/__tests__/XlsxHeaderDialog.spec.ts
@@ -4,6 +4,7 @@ import { createApp, nextTick } from "vue";
import { afterEach, describe, expect, it } from "vitest";
import i18n from "@/i18n";
import XlsxHeaderDialog from "../XlsxHeaderDialog.vue";
+import type { XlsxExportOptions } from "@/lib/export/xlsxHeader";
describe("XlsxHeaderDialog", () => {
afterEach(() => {
@@ -53,4 +54,27 @@ describe("XlsxHeaderDialog", () => {
expect(selectedOptions).toEqual({ headerMode: "name-comment", autoFilter: false });
app.unmount();
});
+
+ it("selects queued execution in the existing options confirmation, defaulting to immediate", async () => {
+ const container = document.createElement("div");
+ document.body.appendChild(container);
+ let selectedOptions: XlsxExportOptions | undefined;
+ const app = createApp(XlsxHeaderDialog, {
+ open: true,
+ showExecutionMode: true,
+ onConfirm: (options: XlsxExportOptions) => {
+ selectedOptions = options;
+ },
+ });
+ app.use(i18n);
+ app.mount(container);
+ await nextTick();
+ expect(document.querySelector<HTMLInputElement>('input[value="immediate"]')!.checked).toBe(true);
+ document.querySelector<HTMLInputElement>('input[value="queued"]')!.click();
+ await nextTick();
+ document.querySelector<HTMLButtonElement>("[data-xlsx-header-confirm]")!.click();
+ await nextTick();
+ expect(selectedOptions).toEqual({ headerMode: "name", autoFilter: false, executionMode: "queued" });
+ app.unmount();
+ });
});
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
index dc048ffd29..a1effced56 100644
--- a/apps/desktop/src/components/grid/DataGrid.vue
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -362,7 +362,7 @@ import { removeVirtualRowIdentifier, saveVirtualRowIdentifier, tableDataVirtualR
import { useToast } from "@/composables/useToast";
import { translateBackendError } from "@/i18n/backend-errors";
import { useNavigationTargets } from "@/composables/useNavigationTargets";
-import { useDataGridExport, type MongoCopyUpdateTarget } from "@/composables/useDataGridExport";
+import { useDataGridExport, type DataGridExportSheet, type MongoCopyUpdateTarget, type UseDataGridExportOptions } from "@/composables/useDataGridExport";
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
import { promptExportSavePath } from "@/lib/export/exportPath";
import { eventTargetAllowsNativeClipboard, isPlainClipboardShortcut, readTextFromClipboard } from "@/lib/common/clipboard";
@@ -648,6 +648,8 @@ interface DataGridProps {
pageSql?: string;
onExecuteSql?: (sql: string) => Promise<void>;
fullExportResult?: (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void) => Promise<QueryResult | undefined>;
+ captureFullExportResult?: UseDataGridExportOptions["captureFullExportResult"];
+ captureQueryResultExportRequest?: UseDataGridExportOptions["captureQueryResultExportRequest"];
queryResultExportRequest?: (options: {
exportId: string;
filePath: string;
@@ -659,11 +661,7 @@ interface DataGridProps {
insertMode?: SqlInsertMode;
}) => Promise<api.QueryResultExportRequest | undefined>;
transferQueryResult?: () => void;
- allExportResults?: Array<{
- sheetName: string;
- result: QueryResult;
- sql?: string;
- }>;
+ allExportResults?: DataGridExportSheet[];
exportFileBaseName?: string;
customSaveHandler?: import("@/composables/useDataGridEditor").CustomSaveHandler;
manualTransactionSessionId?: string;
@@ -9384,6 +9382,23 @@ const {
columnComments: visibleColumnComments,
allColumnComments,
displayValue: (value, index) => formatCell(value, index, undefined, false),
+ captureColumnFormatterDisplay: () => {
+ const formatters = resolvedColumnFormatters.value.map((formatter) => (formatter ? (JSON.parse(JSON.stringify(formatter)) as ColumnFormatterConfig) : undefined));
+ const mongo = usesMongoDocumentGridValues.value;
+ const foreignKeys = new Map([...foreignKeyDisplayLabels.value].map(([index, state]) => [index, { ...state, labels: new Map(state.labels) }]));
+ return (value, index) => {
+ const formatter = formatters[index];
+ if (mongo) {
+ const text = mongoDocumentGridDisplayText(value, formatter);
+ if (text !== undefined) return text;
+ }
+ if (formatter?.kind === "foreign-key-display") {
+ const state = foreignKeys.get(index);
+ return formatForeignKeyDisplayValue(value, state?.labels, state?.keyDataType);
+ }
+ return applyColumnFormatter(value, formatter);
+ };
+ },
editValue: (value, index) => cellEditorTextForValue(value, index),
hasColumnFormatter: (index: number) => Boolean(resolvedColumnFormatters.value[index]),
applyColumnFormattersOnExport: computed(() => settingsStore.editorSettings.applyColumnFormattersOnExport),
@@ -9408,7 +9423,10 @@ const {
selectedRowIds,
hasRowSelection,
resolveSourceValues: resolveLargeValueCells,
+ captureSourceValues: largeValueRuntimeInstance.captureSourceValues,
fullExportResult: props.fullExportResult,
+ captureFullExportResult: () => props.captureFullExportResult?.(),
+ captureQueryResultExportRequest: (queued) => props.captureQueryResultExportRequest?.(queued),
queryResultExportRequest: props.queryResultExportRequest,
hasCompleteLocalResult,
partialLoadCopyInfo: computed(() =>
diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
index 04b643b89d..0fd80c5e29 100644
--- a/apps/desktop/src/components/layout/ContentArea.vue
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -6,6 +6,7 @@ import { canReloadUnavailableDataTab, restoredDataTabReloadFilters } from "@/lib
import { defaultViewForResult } from "@/lib/query/queryResultDefaultView";
import { extractNeo4jNodeCells, projectNeo4jNodeResult } from "@/lib/neo4j/neo4jNodeResult";
import { useNeo4jNodeTableResult } from "@/composables/useNeo4jNodeTableResult";
+import type { DataGridExportSheet } from "@/composables/useDataGridExport";
import { extractGraphCells, graphPropertyFromUpdateResult, type GraphEdge, type GraphNode, type GraphProperty, type GraphResult } from "@/lib/graph/graphResult";
import { graphAdapterForDatabase } from "@/lib/graph/graphAdapters";
import { queryResultMessages } from "@/lib/query/queryResultMessages";
@@ -203,6 +204,7 @@ import { chartableColumnIndexes } from "@/lib/dataGrid/chartData";
import { elasticsearchJsonResponseForResult } from "@/lib/elasticsearch/elasticsearchJsonResponse";
import { elasticsearchProfileBodyForResult, parseElasticsearchProfile } from "@/lib/elasticsearch/elasticsearchProfile";
import * as api from "@/lib/backend/api";
+import type { ExportReadControl } from "@/lib/export/snapshotCompletion";
import type { SqlInsertMode } from "@/lib/export/sqlInsertMode";
import { promptExportSavePath } from "@/lib/export/exportPath";
import { queryResultExportBaseName } from "@/lib/export/saveTextFile";
@@ -259,7 +261,7 @@ type DataGridHandle = DataGridColumnLayoutHandle & {
exportJson: () => Promise<void>;
exportSql: () => Promise<void>;
exportXlsx: () => Promise<void>;
- exportResultSheetsXlsx: (sheets: Array<{ sheetName: string; result: QueryResult; sql?: string }>) => Promise<void>;
+ exportResultSheetsXlsx: (sheets: DataGridExportSheet[]) => Promise<void>;
openXlsx: () => Promise<void>;
};
@@ -692,13 +694,15 @@ const visibleResultItems = computed(() =>
tabularResultItems(props.activeTab.results ?? (props.activeTab.result ? [props.activeTab.result] : undefined), { includeSourceDatabase: includeResultSourceDatabase.value, namingMode: resultTabNamingMode.value, preferComments: preferResultTabComments.value }),
);
const tabularResults = computed(() => tabularResultItems(props.activeTab.results, { includeSourceDatabase: includeResultSourceDatabase.value, namingMode: resultTabNamingMode.value, preferComments: preferResultTabComments.value }));
-const allResultExportSheets = computed(() =>
- tabularResults.value.map((item) => ({
+const allResultExportSheets = computed(() => {
+ const tabId = props.activeTab.id;
+ return tabularResults.value.map((item) => ({
sheetName: item.label || t("tabs.resultN", { n: item.n }),
result: activeEffectiveDatabaseType.value === "neo4j" ? projectNeo4jNodeResult(item.result) : item.result,
sql: item.index === props.activeTab.activeResultIndex ? queryResultExecutionSql(props.activeTab) : item.result.sourceStatement,
- })),
-);
+ captureSourceValues: () => queryStore.captureResultLegacyValuesForExport(tabId, item.result),
+ }));
+});
type ResultSetItem = (typeof visibleResultItems.value)[number];
@@ -746,7 +750,8 @@ async function exportSelectedResultSheets(items: ResultSetItem[]) {
if (resultBatchBusy.value) return;
const dataGrid = dataGridRef.value;
if (!dataGrid) return;
- const sheets = items.filter((item) => !item.result.execution_error && !item.result.server_message).map((item) => ({ sheetName: item.label || t("tabs.resultN", { n: item.n }), result: item.result }));
+ const tabId = props.activeTab.id;
+ const sheets = items.filter((item) => !item.result.execution_error && !item.result.server_message).map((item) => ({ sheetName: item.label || t("tabs.resultN", { n: item.n }), result: item.result, captureSourceValues: () => queryStore.captureResultLegacyValuesForExport(tabId, item.result) }));
if (!sheets.length) return;
resultBatchBusy.value = true;
try {
@@ -810,6 +815,18 @@ async function fetchGridResultForExport(onProgress?: (info: { rowsExported: numb
extractGraphCells(result);
return projectNeo4jNodeResult(result);
}
+function captureGridResultForExport() {
+ const fetch = queryStore.captureTabResultForExport(props.activeTab.id);
+ const isNeo4j = activeEffectiveDatabaseType.value === "neo4j";
+ if (!fetch) return undefined;
+ return async (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void, control?: ExportReadControl) => {
+ const result = await fetch(onProgress, control);
+ if (!result || !isNeo4j) return result;
+ extractNeo4jNodeCells(result);
+ extractGraphCells(result);
+ return projectNeo4jNodeResult(result);
+ };
+}
async function loadQueryResultSourceDdl(): Promise<string | undefined> {
if (props.activeTab.mode !== "query") return undefined;
return loadQueryResultTransferSourceDdl({
@@ -3044,6 +3061,8 @@ defineExpose({
:page-jump-progress="activeTab.resultPageJumpProgress"
:on-execute-sql="async (sql: string) => emit('executeSql', activeTab.id, sql)"
:full-export-result="fetchGridResultForExport"
+ :capture-full-export-result="captureGridResultForExport"
+ :capture-query-result-export-request="hasNeo4jNodes ? undefined : (queued: boolean) => queryStore.captureQueryResultExportRequest(activeTab.id, queued)"
:transfer-query-result="openQueryResultTransfer"
:query-result-export-request="
hasNeo4jNodes
@@ -3573,6 +3592,7 @@ defineExpose({
:total-row-count-loading="activeTab.resultTotalRowCountLoading"
:on-execute-sql="async (sql: string) => emit('executeSql', activeTab.id, sql)"
:full-export-result="(onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void) => queryStore.fetchTabResultForExport(activeTab.id, onProgress)"
+ :capture-full-export-result="() => queryStore.captureTabResultForExport(activeTab.id)"
:export-file-base-name="activeTab.title"
:show-cancel="shouldShowCancelAction(activeTab)"
:cancelling="activeTab.isCancelling"
diff --git a/apps/desktop/src/components/layout/__tests__/ContentArea.exportSources.spec.ts b/apps/desktop/src/components/layout/__tests__/ContentArea.exportSources.spec.ts
new file mode 100644
index 0000000000..8b77174623
--- /dev/null
+++ b/apps/desktop/src/components/layout/__tests__/ContentArea.exportSources.spec.ts
@@ -0,0 +1,84 @@
+// @vitest-environment happy-dom
+import { createApp, defineComponent, h, nextTick, reactive } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { createI18n } from "vue-i18n";
+import { afterEach, expect, it, vi } from "vitest";
+import type { QueryResult, QueryTab } from "@/types/database";
+
+const mocks = vi.hoisted(() => ({ sheets: vi.fn(), selected: vi.fn() }));
+vi.mock("@/components/editor/QueryEditor.vue", () => ({ __esModule: true, default: { render: () => null } }));
+vi.mock("@/components/transfer/QueryResultTransferDialog.vue", () => ({ __esModule: true, default: { render: () => null } }));
+vi.mock("@/components/grid/DataGrid.vue", () => ({
+ __esModule: true,
+ default: defineComponent({
+ props: ["allExportResults"],
+ setup(props, { expose }) {
+ expose({ exportResultSheetsXlsx: mocks.selected });
+ return () => {
+ mocks.sheets(props.allExportResults);
+ return h("div");
+ };
+ },
+ }),
+}));
+vi.mock("@/components/layout/ResultSetNavigator.vue", () => ({
+ default: defineComponent({
+ props: ["items"],
+ emits: ["export-xlsx"],
+ setup:
+ (props, { emit }) =>
+ () =>
+ h("button", { "data-test": "selected-export", onClick: () => emit("export-xlsx", [props.items[1]]) }, "Export selected"),
+ }),
+}));
+
+import ContentArea from "../ContentArea.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+
+let unmount: (() => void) | undefined;
+afterEach(() => {
+ unmount?.();
+ document.body.replaceChildren();
+ window.localStorage?.clear();
+ vi.clearAllMocks();
+});
+
+it("binds all and selected workbook sheets to each original result rather than the active result", async () => {
+ const pinia = createPinia();
+ setActivePinia(pinia);
+ const connection = { id: "oracle-1", name: "Oracle", db_type: "oracle" as const, host: "localhost", port: 1521, username: "test", password: "" };
+ useConnectionStore().connections = [connection];
+ const result = (id: number): QueryResult => ({ columns: ["ID", "BODY"], rows: [[id, "preview"]], affected_rows: 0, execution_time_ms: 1, sourceStatement: `SELECT * FROM T${id}` });
+ const tab = reactive<QueryTab>({ id: "source-tab", title: "Query", connectionId: connection.id, database: "APP", mode: "query", sql: "SELECT * FROM T1; SELECT * FROM T2", isExecuting: false, results: [result(1), result(2)], activeResultIndex: 0 });
+ tab.result = tab.results![0];
+ const store = useQueryStore();
+ store.tabs.push(tab);
+ const capture = vi.spyOn(store, "captureResultLegacyValuesForExport").mockReturnValue(undefined);
+ const host = document.createElement("div");
+ document.body.appendChild(host);
+ const app = createApp({ render: () => h(ContentArea, { activeTab: tab, activeConnection: connection, activeOutputView: "result", executableSql: "", formatSqlRequest: null, compressSqlRequest: null, selectedSql: "", cursorPos: 0, resultOnly: true, blockDangerousRedisCommands: false }) });
+ app.use(pinia);
+ app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));
+ app.mount(host);
+ unmount = () => app.unmount();
+ await vi.waitFor(() => expect(mocks.sheets).toHaveBeenCalled());
+ const sheets = mocks.sheets.mock.lastCall![0];
+ expect(sheets).toHaveLength(2);
+ expect(capture).not.toHaveBeenCalled();
+ sheets[0].captureSourceValues();
+ sheets[1].captureSourceValues();
+ expect(capture.mock.calls).toEqual([
+ ["source-tab", tab.results![0]],
+ ["source-tab", tab.results![1]],
+ ]);
+ capture.mockClear();
+ host.querySelector<HTMLButtonElement>("[data-test=selected-export]")!.click();
+ await nextTick();
+ expect(mocks.selected).toHaveBeenCalledOnce();
+ const selected = mocks.selected.mock.calls[0]![0];
+ expect(selected).toHaveLength(1);
+ expect(selected[0].result).toBe(tab.results![1]);
+ selected[0].captureSourceValues();
+ expect(capture).toHaveBeenCalledExactlyOnceWith("source-tab", tab.results![1]);
+});
diff --git a/apps/desktop/src/components/objects/ObjectBrowser.vue b/apps/desktop/src/components/objects/ObjectBrowser.vue
index e9b103dcbd..7143d1105d 100644
--- a/apps/desktop/src/components/objects/ObjectBrowser.vue
+++ b/apps/desktop/src/components/objects/ObjectBrowser.vue
@@ -145,6 +145,9 @@ import { autoRevealExportedPathIfConfigured, promptExportSavePath } from "@/lib/
import { generateDatabaseExportId } from "@/lib/export/databaseExport";
import { buildXlsxHeaderOverrides, hasXlsxHeaderComments, xlsxHeaderUsesCommentRows, type XlsxExportOptions, type XlsxHeaderMode } from "@/lib/export/xlsxHeader";
import { showSqlInsertModeDialog, type SqlInsertDialect, type SqlInsertMode } from "@/lib/export/sqlInsertMode";
+import { showExportExecutionModeDialog } from "@/lib/export/exportExecutionMode";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
import { csvNullLiteralForMode } from "@/lib/export/csvNullMode";
import { copyToClipboard, eventTargetAllowsAppClipboardShortcut, eventTargetUsesNativeClipboard } from "@/lib/common/clipboard";
import { encodeSpreadsheetTsvCell } from "@/lib/common/spreadsheetTsv";
@@ -646,7 +649,8 @@ let stopColumnResize: (() => void) | null = null;
let preserveObjectFilterScrollOnce = false;
// Export via background tracker
-const { addTask: addExportTask, updateTableExportTask } = useExportTracker();
+const exportTracker = useExportTracker();
+const { addTask: addExportTask, updateTableExportTask } = exportTracker;
const needsSchema = computed(() => isSchemaAware(props.connection.db_type) && !connectionUsesDatabaseObjectTreeMode(props.connection));
const canDropTargetCascade = computed(() => dropTarget.value?.type === "TABLE" && supportsDropTableCascade(effectiveDatabaseType.value));
@@ -3819,13 +3823,14 @@ async function exportDataLegacy(row: ObjectBrowserRow, format: "json") {
}
async function exportData(row: ObjectBrowserRow, format: "csv" | "json" | "sql", insertDialect: SqlInsertDialect = "source") {
- if (format === "json") {
+ if (format === "json" && !isTauriRuntime()) {
await exportDataLegacy(row, format);
return;
}
- const sqlExportOptions = format === "sql" ? await showSqlInsertModeDialog({ allowSplit: true }) : undefined;
+ const captured = captureTableDataExport(row);
+ const sqlExportOptions = format === "sql" ? await showSqlInsertModeDialog({ allowSplit: true, showExecutionMode: isTauriRuntime() }) : undefined;
if (format === "sql" && sqlExportOptions === null) return;
- await exportTableData(row, format, undefined, "name", true, sqlExportOptions?.insertMode ?? "batch", sqlExportOptions?.splitMaxMb, insertDialect);
+ await exportTableData(row, format, undefined, "name", true, sqlExportOptions?.insertMode ?? "batch", sqlExportOptions?.splitMaxMb, insertDialect, captured, sqlExportOptions?.executionMode);
}
function showObjectBrowserXlsxHeaderDialog(hasComments: boolean): Promise<XlsxExportOptions | null> {
@@ -3837,6 +3842,7 @@ function showObjectBrowserXlsxHeaderDialog(hasComments: boolean): Promise<XlsxEx
const app = createApp(XlsxHeaderDialog, {
open: true,
showHeaderOptions: hasComments,
+ showExecutionMode: isTauriRuntime(),
onConfirm: (exportOptions: XlsxExportOptions) => {
resolve(exportOptions);
app.unmount();
@@ -3854,31 +3860,63 @@ function showObjectBrowserXlsxHeaderDialog(hasComments: boolean): Promise<XlsxEx
}
async function exportDataXlsx(row: ObjectBrowserRow) {
- const schema = row.schema || selectedSchema.value;
+ const captured = captureTableDataExport(row);
+ const { connectionId, database, schema, catalog } = captured;
let columnInfos: ColumnInfo[] | undefined;
try {
- columnInfos = await api.getColumns(props.connection.id, props.database, schema || props.database, row.name, props.catalog);
+ columnInfos = await api.getColumns(connectionId, database, schema || database, captured.tableName, catalog);
} catch {
// Export still works with field-name headers when column metadata is unavailable.
}
const exportOptions = await showObjectBrowserXlsxHeaderDialog(hasXlsxHeaderComments(columnInfos?.map((column) => column.comment)));
if (exportOptions === null) return;
- await exportTableData(row, "xlsx", columnInfos, exportOptions.headerMode, exportOptions.autoFilter);
+ await exportTableData(row, "xlsx", columnInfos, exportOptions.headerMode, exportOptions.autoFilter, "batch", undefined, "source", captured, exportOptions.executionMode);
}
-async function exportTableData(row: ObjectBrowserRow, format: "csv" | "xlsx" | "sql", columnInfos?: ColumnInfo[], headerMode: XlsxHeaderMode = "name", autoFilter = true, insertMode: SqlInsertMode = "batch", splitMaxMb?: number, insertDialect: SqlInsertDialect = "source") {
- const schema = row.schema || selectedSchema.value;
+function captureTableDataExport(row: ObjectBrowserRow) {
+ return {
+ connectionId: props.connection.id,
+ fingerprint: connectionConfigFingerprint(props.connection),
+ connectionType: props.connection.db_type,
+ timeoutSecs: props.connection.query_timeout_secs,
+ database: props.database,
+ catalog: props.catalog,
+ schema: row.schema || selectedSchema.value,
+ tableName: row.name,
+ databaseType: effectiveDatabaseType.value,
+ identifierQuote: connectionStore.connectionIdentifierQuote(props.connection.id),
+ settings: { ...settingsStore.editorSettings },
+ };
+}
+
+async function exportTableData(
+ row: ObjectBrowserRow,
+ format: "csv" | "xlsx" | "sql" | "json",
+ columnInfos?: ColumnInfo[],
+ headerMode: XlsxHeaderMode = "name",
+ autoFilter = true,
+ insertMode: SqlInsertMode = "batch",
+ splitMaxMb?: number,
+ insertDialect: SqlInsertDialect = "source",
+ captured = captureTableDataExport(row),
+ selectedMode?: ManualExportMode,
+) {
+ const { connectionId, database, schema, catalog, tableName, identifierQuote, databaseType, settings } = captured;
+ columnInfos = columnInfos?.map((column) => ({ ...column }));
+ const native = isTauriRuntime();
+ const mode = native ? (selectedMode ?? (await showExportExecutionModeDialog())) : "immediate";
+ if (mode === null) return;
const splitSqlOutput = format === "sql" && splitMaxMb !== undefined;
// Save dialog first
let filePath = "";
- const defaultName = `${row.name}.${splitSqlOutput ? "zip" : format}`;
+ const defaultName = `${tableName}.${splitSqlOutput ? "zip" : format}`;
if (isTauriRuntime()) {
try {
- const filter = format === "csv" ? { name: "CSV", extensions: ["csv"] } : format === "xlsx" ? { name: "Excel", extensions: ["xlsx"] } : splitSqlOutput ? { name: "ZIP", extensions: ["zip"] } : { name: "SQL", extensions: ["sql"] };
+ const filter = format === "csv" ? { name: "CSV", extensions: ["csv"] } : format === "xlsx" ? { name: "Excel", extensions: ["xlsx"] } : format === "json" ? { name: "JSON", extensions: ["json"] } : splitSqlOutput ? { name: "ZIP", extensions: ["zip"] } : { name: "SQL", extensions: ["sql"] };
const path = await promptExportSavePath({
defaultFileName: defaultName,
filters: [filter],
@@ -3894,87 +3932,181 @@ async function exportTableData(row: ObjectBrowserRow, format: "csv" | "xlsx" | "
filePath = `__web_export_${webExportId}.${splitSqlOutput ? "zip" : format}`;
}
- let task: ExportTask | null = null;
- try {
- if (isVictoriaMetrics.value) {
- const result = await fetchTableDataForExport({
- databaseType: effectiveDatabaseType.value,
- schema,
- tableName: row.name,
- executePage: (sql) => api.executeQuery(props.connection.id, props.database, sql),
+ if (native && (props.connection.id !== connectionId || props.database !== database || props.catalog !== catalog || (row.schema || selectedSchema.value) !== schema || row.name !== tableName || connectionConfigFingerprint(props.connection) !== captured.fingerprint)) {
+ toast(t("exportProgress.connectionChanged"), 5000);
+ return;
+ }
+ let task: ExportTask | null = native ? addExportTask(tableName, format, filePath) : null;
+ const controller = new AbortController();
+ let backendStarted = false;
+ let unknown = false;
+ let unknownMessage: string | undefined;
+ let terminal: api.TableExportProgress | undefined;
+ const check = () => {
+ if (!native) return;
+ if (unknown) throw new SnapshotCompletionError("unknown", unknownMessage ?? "Export completion was not confirmed");
+ if (controller.signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ const config = connectionStore.getConfig(connectionId);
+ if (!config || connectionConfigFingerprint(config) !== captured.fingerprint) throw new SnapshotCompletionError("failed", t("exportProgress.connectionChanged"));
+ };
+ const read = async <T>(request: () => Promise<T>, cleanup = false): Promise<T> => {
+ if (!cleanup) check();
+ let value: T;
+ try {
+ value = await request();
+ } catch (error) {
+ if (!native) throw error;
+ unknown = true;
+ unknownMessage ??= error instanceof Error ? error.message : String(error);
+ throw new SnapshotCompletionError("unknown", unknownMessage);
+ }
+ if (!cleanup && task?.canCancel !== false) check();
+ return value;
+ };
+ const execute = async (): Promise<"settled" | "unknown"> => {
+ if (native && task)
+ exportTracker.registerTaskCancelHandler(task.exportId, async () => {
+ controller.abort();
+ task!.status = "Cancelling";
+ if (backendStarted) await api.cancelTableExport(task!.exportId);
});
- if (format === "csv") {
- await api.exportQueryResultCsv(filePath, result.columns, result.rows, settingsStore.editorSettings.csvQuoteMode, csvNullLiteralForMode(settingsStore.editorSettings.csvNullMode));
- } else {
- const comments = result.columns.map((name) => columnInfos?.find((column) => column.name.toLocaleLowerCase() === name.toLocaleLowerCase())?.comment);
- const headerOverrides = buildXlsxHeaderOverrides(result.columns, comments, headerMode);
- await api.exportQueryResultXlsx(filePath, row.name, result.columns, result.column_types ?? result.columns.map(() => ""), headerOverrides, result.rows, undefined, autoFilter, settingsStore.editorSettings.globalDateTimeExportFormat || undefined, xlsxHeaderUsesCommentRows(headerMode));
+ try {
+ check();
+ if (databaseType === "victoriametrics" || format === "json") {
+ const queryColumns = captured.connectionType === "neo4j" ? (await read(() => api.getColumns(connectionId, database, schema || database, tableName, catalog))).map((column) => column.name) : undefined;
+ const useAgentCursor = captured.connectionType === "cassandra";
+ const clientSessionId = useAgentCursor ? `table-export:${generateDatabaseExportId()}` : undefined;
+ const result = await fetchTableDataForExport({
+ databaseType,
+ identifierQuote,
+ schema,
+ tableName,
+ columns: queryColumns,
+ useAgentCursor,
+ executePage: async (sql, cursorOptions) => {
+ const result = await read(() => (cursorOptions ? api.executeQuery(connectionId, database, sql, undefined, undefined, { ...cursorOptions, clientSessionId, catalog, timeoutSecs: captured.timeoutSecs }) : api.executeQuery(connectionId, database, sql)));
+ if (native && result.execution_error) throw new SnapshotCompletionError(result.error?.operationOutcome === "not_started" ? "failed" : "unknown", translateBackendError(t, result.error ?? String(result.rows[0]?.[0] ?? "Query failed")));
+ if (native && (result.truncated || result.large_value_cells?.length)) throw new SnapshotCompletionError("failed", "Incomplete table export result");
+ return result;
+ },
+ closeCursor: useAgentCursor
+ ? async (sessionId) => {
+ try {
+ if (sessionId) await read(() => api.closeQuerySession(connectionId, database, sessionId, clientSessionId, catalog), true);
+ } finally {
+ await read(() => (native ? api.closeClientConnectionSession(connectionId, database, clientSessionId!, catalog, true) : api.closeClientConnectionSession(connectionId, database, clientSessionId!, catalog)), true);
+ }
+ }
+ : undefined,
+ });
+ check();
+ if (native && task) task.canCancel = false;
+ if (format === "json") await read(() => api.exportQueryResultJson(filePath, result.columns, result.rows));
+ else if (format === "csv") {
+ await read(() => api.exportQueryResultCsv(filePath, result.columns, result.rows, settings.csvQuoteMode, csvNullLiteralForMode(settings.csvNullMode)));
+ } else {
+ const comments = result.columns.map((name) => columnInfos?.find((column) => column.name.toLocaleLowerCase() === name.toLocaleLowerCase())?.comment);
+ const headerOverrides = buildXlsxHeaderOverrides(result.columns, comments, headerMode);
+ await read(() => api.exportQueryResultXlsx(filePath, tableName, result.columns, result.column_types ?? result.columns.map(() => ""), headerOverrides, result.rows, undefined, autoFilter, settings.globalDateTimeExportFormat || undefined, xlsxHeaderUsesCommentRows(headerMode)));
+ }
+ if (task) {
+ task.status = "Done";
+ task.rowsExported = result.rows.length;
+ task.totalRows = result.rows.length;
+ task.finishedAt = Date.now();
+ }
+ toast(t("grid.exported"));
+ void autoRevealExportedPathIfConfigured(filePath);
+ return "settled";
}
- toast(t("grid.exported"));
- void autoRevealExportedPathIfConfigured(filePath);
- return;
- }
- let columns: string[] | undefined;
- let columnComments: (string | null)[] | undefined;
-
- if (columnInfos) {
- columns = columnInfos.map((c) => c.name);
- if (format === "xlsx") {
- columnComments = buildXlsxHeaderOverrides(
- columns,
- columnInfos.map((column) => column.comment),
- headerMode,
- );
+ let columns: string[] | undefined;
+ let columnComments: (string | null)[] | undefined;
+
+ if (columnInfos) {
+ columns = columnInfos.map((c) => c.name);
+ if (format === "xlsx") {
+ columnComments = buildXlsxHeaderOverrides(
+ columns,
+ columnInfos.map((column) => column.comment),
+ headerMode,
+ );
+ }
+ } else if (captured.connectionType === "neo4j") {
+ const infos = await read(() => api.getColumns(connectionId, database, schema || database, tableName, catalog));
+ columns = infos.map((c) => c.name);
}
- } else if (props.connection.db_type === "neo4j") {
- const infos = await api.getColumns(props.connection.id, props.database, schema || props.database, row.name, props.catalog);
- columns = infos.map((c) => c.name);
- }
-
- task = addExportTask(row.name, format, filePath);
- const currentTask = task;
- const rowLimit = settingsStore.editorSettings.exportRowLimitEnabled ? settingsStore.editorSettings.exportRowLimit : null;
- const request: api.TableExportRequest = {
- exportId: currentTask.exportId,
- connectionId: props.connection.id,
- database: props.database,
- schema,
- identifierQuote: connectionStore.connectionIdentifierQuote(props.connection.id),
- tableName: row.name,
- filePath,
- format,
- ...(format === "sql"
- ? {
- insertMode,
- insertDialect,
- splitMaxMb,
- omitDatabaseQualifier: dropsSchemaQualifier(effectiveDatabaseType.value, settingsStore.editorSettings.generateSqlIncludeDatabaseName, props.catalog),
- }
- : {}),
- csvQuoteMode: settingsStore.editorSettings.csvQuoteMode,
- nullLiteral: csvNullLiteralForMode(settingsStore.editorSettings.csvNullMode),
- columns,
- columnComments: format === "xlsx" ? columnComments : undefined,
- headerCommentRows: format === "xlsx" ? xlsxHeaderUsesCommentRows(headerMode) : undefined,
- autoFilter: format === "xlsx" ? autoFilter : undefined,
- batchSize: settingsStore.editorSettings.exportBatchSize,
- skipCount: format === "sql",
- rowLimit,
- };
- const terminalProgress = await api.startTableExport(request, (progress) => {
- updateTableExportTask(currentTask.exportId, progress);
- });
- if (terminalProgress.status === "Done") {
- toast(t("grid.exported"));
- }
- } catch (e: any) {
- if (task) {
- task.status = "Error";
- task.errorMessage = e?.message || String(e);
+ task ??= addExportTask(tableName, format, filePath);
+ const currentTask = task;
+ const rowLimit = settings.exportRowLimitEnabled ? settings.exportRowLimit : null;
+ const request: api.TableExportRequest = {
+ exportId: currentTask.exportId,
+ connectionId,
+ database,
+ schema,
+ identifierQuote,
+ tableName,
+ filePath,
+ format,
+ ...(format === "sql"
+ ? {
+ insertMode,
+ insertDialect,
+ splitMaxMb,
+ omitDatabaseQualifier: dropsSchemaQualifier(databaseType, settings.generateSqlIncludeDatabaseName, catalog),
+ }
+ : {}),
+ csvQuoteMode: settings.csvQuoteMode,
+ nullLiteral: csvNullLiteralForMode(settings.csvNullMode),
+ columns,
+ columnComments: format === "xlsx" ? columnComments : undefined,
+ headerCommentRows: format === "xlsx" ? xlsxHeaderUsesCommentRows(headerMode) : undefined,
+ autoFilter: format === "xlsx" ? autoFilter : undefined,
+ batchSize: settings.exportBatchSize,
+ skipCount: format === "sql",
+ rowLimit,
+ };
+
+ check();
+ backendStarted = true;
+ const onProgress = (progress: api.TableExportProgress) => {
+ if (progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled") terminal = progress;
+ updateTableExportTask(currentTask.exportId, progress);
+ };
+ const terminalProgress = await (native ? api.startTableExport(request, onProgress, true) : api.startTableExport(request, onProgress));
+ if (native && terminalProgress.status !== "Done" && terminalProgress.status !== "Error" && terminalProgress.status !== "Cancelled") throw new SnapshotCompletionError("unknown", "Export completion was not confirmed");
+ updateTableExportTask(currentTask.exportId, terminalProgress);
+ if (terminalProgress.status === "Done") {
+ toast(t("grid.exported"));
+ }
+ return "settled";
+ } catch (e: any) {
+ if (native && terminal?.status === "Done" && task) {
+ updateTableExportTask(task.exportId, terminal);
+ return "settled";
+ }
+ unknown ||= native && ((backendStarted && !terminal && !(e instanceof SnapshotCompletionError && e.status === "failed")) || (e instanceof SnapshotCompletionError && e.status === "unknown"));
+ if (task) {
+ task.status = unknown ? "Unknown" : native && (terminal?.status === "Cancelled" || (e instanceof SnapshotCompletionError && e.status === "cancelled")) ? "Cancelled" : "Error";
+ task.errorMessage = e?.message || String(e);
+ task.finishedAt = unknown ? undefined : Date.now();
+ }
+ toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+ return unknown ? "unknown" : "settled";
+ } finally {
+ if (native && task) {
+ task.canCancel = false;
+ if (!unknown) exportTracker.unregisterTaskCancelHandler(task.exportId);
+ }
}
- toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+ };
+ if (!native) {
+ await execute();
+ return;
}
+ let completion: Promise<"settled" | "unknown"> | undefined;
+ exportTracker.submitExportTask(task!, mode, () => (completion = execute()));
+ if (mode === "immediate") await completion;
}
function requestCopyAsNewTable(row: ObjectBrowserRow) {
diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.exportQueue.component.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.exportQueue.component.spec.ts
new file mode 100644
index 0000000000..71f00237d7
--- /dev/null
+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.exportQueue.component.spec.ts
@@ -0,0 +1,215 @@
+// @vitest-environment happy-dom
+import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import ObjectBrowser from "@/components/objects/ObjectBrowser.vue";
+import type { ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import type { ConnectionConfig } from "@/types/database";
+import type { TableExportProgress, TableExportRequest } from "@/lib/backend/api";
+import { useExportTracker } from "@/composables/useExportTracker";
+import { invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";
+
+const mocks = vi.hoisted(() => ({
+ mode: vi.fn(),
+ save: vi.fn(),
+ start: vi.fn(),
+ cancel: vi.fn(),
+ query: vi.fn(),
+ json: vi.fn(),
+ toast: vi.fn(),
+ menu: [] as ContextMenuItem[],
+ settings: { shortcuts: { refreshData: "F5" }, objectBrowserViewMode: "list", objectBrowserShowCheckbox: false, exportBatchSize: 123, csvQuoteMode: "minimal", csvNullMode: "empty", exportRowLimitEnabled: false, generateSqlIncludeDatabaseName: true },
+}));
+vi.mock("@/lib/backend/api", () => ({
+ listObjects: vi.fn(async () => [{ name: "orders", object_type: "TABLE" }]),
+ listSchemas: vi.fn(async () => []),
+ getColumns: vi.fn(async () => []),
+ listObjectStatistics: vi.fn(async () => []),
+ startTableExport: mocks.start,
+ cancelTableExport: mocks.cancel,
+ executeQuery: mocks.query,
+ exportQueryResultJson: mocks.json,
+ buildTableSelectSql: vi.fn(async ({ tableName }) => `SELECT * FROM ${tableName}`),
+}));
+vi.mock("@/stores/connectionStore", () => ({ useConnectionStore: () => ({ getConfig: () => connection, ensureConnected: vi.fn(async () => undefined), connectionIdentifierQuote: () => "`", orderByPinnedTreeNodes: (rows: unknown[]) => rows }) }));
+vi.mock("@/stores/queryStore", () => ({ useQueryStore: () => ({}) }));
+vi.mock("@/stores/settingsStore", () => ({ useSettingsStore: () => ({ editorSettings: mocks.settings }) }));
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => true }));
+vi.mock("@/lib/export/exportExecutionMode", () => ({ showExportExecutionModeDialog: mocks.mode }));
+vi.mock("@/lib/export/exportPath", () => ({ promptExportSavePath: mocks.save, autoRevealExportedPathIfConfigured: vi.fn() }));
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key, locale: ref("en-US") }) }));
+vi.mock("@/i18n", () => ({ default: { install() {} } }));
+vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
+vi.mock("@/composables/useSqlHighlighter", () => ({ useSqlHighlighter: () => ({ highlight: (sql: string) => sql }) }));
+vi.mock("vue-virtual-scroller", () => ({
+ RecycleScroller: defineComponent({
+ props: { items: { type: Array, default: () => [] } },
+ setup:
+ (props, { slots }) =>
+ () =>
+ h(
+ "div",
+ props.items.map((item) => slots.default?.({ item })),
+ ),
+ }),
+}));
+vi.mock("@/components/ui/CustomContextMenu.vue", () => ({
+ default: defineComponent({
+ props: ["items"],
+ setup:
+ (props, { slots }) =>
+ () =>
+ slots.default?.({
+ onContextMenu: () => {
+ mocks.menu = typeof props.items === "function" ? props.items() : props.items;
+ },
+ isOpen: false,
+ }),
+ }),
+}));
+vi.mock("@/components/ui/searchable-select", () => ({ SearchableSelect: { render: () => null } }));
+vi.mock("@/components/ui/ToolbarOverflowMenu.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/editor/QueryEditor.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/editor/DangerConfirmDialog.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/objects/ProcedureExecutionDialog.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/objects/CustomTypeInfoPanel.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/export/XlsxHeaderDialog.vue", () => ({ default: { render: () => null } }));
+
+const connection = { id: "export-queue-mysql", name: "MySQL", db_type: "mysql", database: "app", transport_layers: [] } as unknown as ConnectionConfig;
+const mounted: Array<{ app: App; host: HTMLElement }> = [];
+const operations: Array<{ request: TableExportRequest; progress: (value: TableExportProgress) => void; resolve: (value: TableExportProgress) => void; reject: (error: Error) => void }> = [];
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.menu = [];
+ operations.length = 0;
+ mocks.settings.exportBatchSize = 123;
+ mocks.mode.mockResolvedValue("queued");
+ mocks.save.mockResolvedValue("C:/exports/orders.csv");
+ mocks.cancel.mockResolvedValue(undefined);
+ mocks.query.mockReset().mockResolvedValue({ columns: ["ID"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 });
+ mocks.json.mockReset().mockResolvedValue(undefined);
+ mocks.start.mockImplementation((request, progress) => new Promise((resolve, reject) => operations.push({ request, progress, resolve, reject })));
+ invalidateObjectBrowserRowsCache({});
+});
+afterEach(() => {
+ for (const { app, host } of mounted.splice(0)) {
+ app.unmount();
+ host.remove();
+ }
+ const tracker = useExportTracker();
+ for (const task of tracker.tasks.value) tracker.removeTask(task.exportId);
+ invalidateObjectBrowserRowsCache({});
+});
+async function mountBrowser() {
+ const database = ref("app");
+ const host = document.createElement("div");
+ document.body.append(host);
+ const app = createApp({ setup: () => () => h(ObjectBrowser, { connection, database: database.value }) });
+ mounted.push({ app, host });
+ app.mount(host);
+ await vi.waitFor(() => expect(host.textContent).toContain("orders"));
+ const row = host.querySelector<HTMLElement>(".grid.h-\\[34px\\]")!;
+ row.dispatchEvent(new MouseEvent("contextmenu", { bubbles: true, cancelable: true }));
+ return {
+ database,
+ export: async (format: string) => {
+ const find = (items: ContextMenuItem[]): ContextMenuItem | undefined => {
+ for (const item of items) {
+ if (item.label === `contextMenu.exportData · ${format}`) return item;
+ const child = item.children && find(item.children);
+ if (child) return child;
+ }
+ };
+ const item = find(mocks.menu);
+ expect(item, JSON.stringify(mocks.menu.map((item) => ({ label: item.label, children: item.children?.map((item) => item.label) })))).toBeDefined();
+ const action = item!.action!;
+ await action();
+ await nextTick();
+ },
+ };
+}
+function finish(index: number, status: "Done" | "Cancelled" = "Done") {
+ const operation = operations[index]!;
+ const terminal: TableExportProgress = { exportId: operation.request.exportId, tableName: "orders", rowsExported: 10, totalRows: 10, status };
+ operation.progress(terminal);
+ operation.resolve(terminal);
+}
+it("captures the actual object-menu target and settings before queue waiting", async () => {
+ const tracker = useExportTracker();
+ let release!: () => void;
+ tracker.submitExportTask(
+ tracker.addTask("blocker", "csv", "first.csv"),
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ const browser = await mountBrowser();
+ await browser.export("CSV");
+ expect(operations).toHaveLength(0);
+ browser.database.value = "other";
+ mocks.settings.exportBatchSize = 999;
+ release();
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ expect(operations[0]!.request).toMatchObject({ connectionId: connection.id, database: "app", tableName: "orders", batchSize: 123, filePath: "C:/exports/orders.csv" });
+ finish(0);
+ await vi.waitFor(() => expect(tracker.tasks.value[1]!.status).toBe("Done"));
+});
+it("does not let a cancel acknowledgement release a running object export", async () => {
+ const browser = await mountBrowser();
+ await browser.export("CSV");
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ const tracker = useExportTracker();
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(next).not.toHaveBeenCalled();
+ expect(mocks.cancel).toHaveBeenCalledOnce();
+ finish(0, "Cancelled");
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+});
+it("queues JSON before reading and waits for its actual writer", async () => {
+ const tracker = useExportTracker();
+ let release!: () => void;
+ tracker.submitExportTask(
+ tracker.addTask("blocker", "csv", "first.csv"),
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ let written!: () => void;
+ mocks.json.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ written = resolve;
+ }),
+ );
+ const browser = await mountBrowser();
+ await browser.export("JSON");
+ expect(mocks.query).not.toHaveBeenCalled();
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ release();
+ await vi.waitFor(() => expect(mocks.json).toHaveBeenCalledOnce());
+ expect(mocks.json).toHaveBeenCalledWith("C:/exports/orders.csv", ["ID"], [[7]]);
+ expect(tracker.tasks.value[1]!.canCancel).toBe(false);
+ expect(next).not.toHaveBeenCalled();
+ written();
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+});
+
+it("keeps a transport rejection unknown instead of advancing the queue after cancellation", async () => {
+ const browser = await mountBrowser();
+ await browser.export("CSV");
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ const tracker = useExportTracker();
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ operations[0]!.reject(new Error("invoke reply lost"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe("Unknown"));
+ expect(tracker.tasks.value[0]!.finishedAt).toBeUndefined();
+ expect(next).not.toHaveBeenCalled();
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataGridExport.queue.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridExport.queue.spec.ts
new file mode 100644
index 0000000000..d3ab16c717
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useDataGridExport.queue.spec.ts
@@ -0,0 +1,1049 @@
+import { computed, reactive, ref } from "vue";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { UseDataGridExportOptions } from "../useDataGridExport";
+import type { TableExportProgress, TableExportRequest, QueryResultExportRequest } from "@/lib/backend/api";
+import type { SnapshotExportRequest, LargeValueChunk } from "@/lib/backend/http";
+import type { QueryResult } from "@/types/database";
+import "../useDataGridExport";
+
+const mocks = vi.hoisted(() => ({
+ mode: vi.fn(),
+ start: vi.fn(),
+ queryStart: vi.fn(),
+ queryCancel: vi.fn(),
+ snapshot: vi.fn(),
+ readChunk: vi.fn(),
+ memoryWrite: vi.fn(),
+ buildInsert: vi.fn(),
+ sqlMode: vi.fn(),
+ createTemp: vi.fn(),
+ openTemp: vi.fn(),
+ cancelQuery: vi.fn(),
+ cancel: vi.fn(),
+ save: vi.fn(),
+ toast: vi.fn(),
+ ensure: vi.fn(),
+ config: { id: "oracle-1", name: "Oracle", db_type: "oracle", host: "test-instance" },
+}));
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => true }));
+vi.mock("@/lib/export/exportExecutionMode", () => ({ showExportExecutionModeDialog: mocks.mode }));
+vi.mock("@/lib/export/sqlInsertMode", () => ({ showSqlInsertModeDialog: mocks.sqlMode }));
+vi.mock("@/lib/export/exportPath", () => ({ promptExportSavePath: mocks.save, autoRevealExportedPathIfConfigured: vi.fn() }));
+vi.mock("@/lib/backend/api", () => ({
+ startTableExport: mocks.start,
+ cancelTableExport: mocks.cancel,
+ startQueryResultExport: mocks.queryStart,
+ cancelQueryResultExport: mocks.queryCancel,
+ exportSnapshotResult: mocks.snapshot,
+ readLargeValueChunk: mocks.readChunk,
+ cancelQuery: mocks.cancelQuery,
+ exportQueryResultCsv: mocks.memoryWrite,
+ exportQueryResultJson: mocks.memoryWrite,
+ exportQueryResultMarkdown: mocks.memoryWrite,
+ exportQueryResultHtml: mocks.memoryWrite,
+ exportQueryResultXlsx: mocks.memoryWrite,
+ exportQueryResultsXlsx: mocks.memoryWrite,
+ buildExportSqlInsert: mocks.buildInsert,
+ createQueryResultTempFile: mocks.createTemp,
+ openQueryResultTempFile: mocks.openTemp,
+}));
+vi.mock("@tauri-apps/plugin-fs", () => ({ writeTextFile: mocks.memoryWrite }));
+vi.mock("@/stores/connectionStore", () => ({ useConnectionStore: () => ({ getConfig: () => mocks.config, ensureConnected: mocks.ensure, connectionStateRevision: () => 0, isCurrentConnectionStateRevision: () => true }) }));
+vi.mock("@/stores/settingsStore", () => ({ useSettingsStore: () => ({ editorSettings: { exportBatchSize: 1000, exportRowLimitEnabled: false, csvQuoteMode: "minimal", csvNullMode: "empty", numericColumnRightAlign: true } }) }));
+vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+vi.mock("@/i18n", () => ({ default: { install() {} } }));
+vi.mock("@/composables/useDataGridExtractor", () => ({ useDataGridExtractor: () => ({ canCopyWithExtractor: vi.fn() }) }));
+vi.mock("@/lib/schema/oracleRoutineDeploy", () => ({}));
+
+function fixture() {
+ const source = reactive({ table: "ORDERS", schema: "HR", filter: "ID > 0", connection: "oracle-1", database: "XE" });
+ const progress = ref({ title: "", tableName: "", format: "", rowsExported: 0, totalRows: null as number | null, status: "", errorMessage: null as string | null, filePath: null as string | null, startedAt: undefined as number | undefined, finishedAt: undefined as number | undefined });
+ const options: UseDataGridExportOptions = {
+ columns: computed(() => ["ID"]),
+ displayItems: computed(() => []),
+ sql: computed(() => "SELECT ID FROM ORDERS"),
+ tableMeta: computed(() => ({ tableName: source.table, schema: source.schema, primaryKeys: ["ID"], columns: [{ name: "ID", data_type: "NUMBER" }] })),
+ databaseType: computed(() => "oracle"),
+ connectionId: computed(() => source.connection),
+ database: computed(() => source.database),
+ context: computed(() => "table-data"),
+ sourceColumns: computed(() => ["ID"]),
+ columnTypes: computed(() => ["NUMBER"]),
+ whereInput: computed(() => source.filter),
+ orderBy: computed(() => "ID"),
+ exportBatchSize: computed(() => 1000),
+ hasCellSelection: computed(() => false),
+ selectedCells: computed(() => ({ columns: [], rows: [] })),
+ selectedCellMatrix: computed(() => null),
+ selectedRange: computed(() => null),
+ contextCell: ref(null),
+ contextSelectionIsSynthetic: ref(false),
+ getRowItem: () => undefined,
+ selectedRowIds: ref(new Set<number>()),
+ hasRowSelection: computed(() => false),
+ exportProgressState: progress,
+ exportProgressDialog: ref(false),
+ exportCanMinimize: ref(false),
+ exportCancelHandler: ref(null),
+ };
+ return { source, options, progress };
+}
+
+describe("data grid queued table export", () => {
+ const pending: Array<{ request: TableExportRequest | QueryResultExportRequest; progress: (progress: TableExportProgress) => void; resolve: (progress: TableExportProgress) => void; reject: (error: Error) => void }> = [];
+ const snapshots: Array<{ request: SnapshotExportRequest; path: string; resolve: () => void; reject: (error: Error) => void }> = [];
+ const reads: Array<{ resolve: (chunk: LargeValueChunk) => void }> = [];
+ beforeEach(async () => {
+ vi.resetModules();
+ vi.clearAllMocks();
+ const { createPinia, setActivePinia } = await import("pinia");
+ setActivePinia(createPinia());
+ pending.length = 0;
+ snapshots.length = 0;
+ reads.length = 0;
+ mocks.mode.mockResolvedValue("queued");
+ let file = 0;
+ mocks.save.mockImplementation(async () => `C:/exports/report-${++file}.csv`);
+ mocks.cancel.mockResolvedValue(undefined);
+ mocks.queryCancel.mockResolvedValue(undefined);
+ mocks.cancelQuery.mockResolvedValue(undefined);
+ mocks.ensure.mockResolvedValue(undefined);
+ mocks.memoryWrite.mockReset().mockResolvedValue(undefined);
+ mocks.buildInsert.mockResolvedValue("INSERT original captured SQL");
+ mocks.sqlMode.mockResolvedValue({ insertMode: "batch" });
+ mocks.createTemp.mockImplementation(async (extension) => `C:/exports/temp.${extension}`);
+ mocks.openTemp.mockReset().mockResolvedValue(undefined);
+ mocks.start.mockImplementation((request, progress) => new Promise((resolve, reject) => pending.push({ request, progress, resolve, reject })));
+ mocks.queryStart.mockImplementation((request, progress) => new Promise((resolve, reject) => pending.push({ request, progress, resolve, reject })));
+ mocks.snapshot.mockImplementation((request, path) => new Promise<void>((resolve, reject) => snapshots.push({ request, path, resolve, reject })));
+ mocks.readChunk.mockImplementation(() => new Promise<LargeValueChunk>((resolve) => reads.push({ resolve })));
+ });
+
+ function finish(index: number, status: "Done" | "Cancelled" = "Done") {
+ const item = pending[index]!;
+ const progress: TableExportProgress = { exportId: item.request.exportId, tableName: "tableName" in item.request ? item.request.tableName : "Query Result", rowsExported: 10, totalRows: 10, status, errorMessage: null };
+ item.progress(progress);
+ item.resolve(progress);
+ }
+
+ it("accepts another export while waiting, then uses its captured target without overwriting the current dialog", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { source, options, progress } = fixture();
+ const grid = useDataGridExport(options);
+ await grid.exportCsv();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ source.filter = "ID > 100";
+ await grid.exportCsv();
+ expect(pending).toHaveLength(1);
+ expect(progress.value.status).toBe("Queued");
+ expect(progress.value.startedAt).toBeUndefined();
+ source.table = "OTHER";
+ source.schema = "PRIVATE";
+ source.filter = "ID < 0";
+ source.database = "OTHER_DATABASE";
+ finish(0);
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ expect(pending[1]!.request).toEqual(expect.objectContaining({ tableName: "ORDERS", schema: "HR", database: "XE", whereInput: "ID > 100", filePath: "C:/exports/report-2.csv" }));
+ expect(progress.value.filePath).toBe("C:/exports/report-2.csv");
+ expect(progress.value.status).toBe("Running");
+ expect(useExportTracker().tasks.value[0]!.status).toBe("Done");
+ finish(1);
+ await vi.waitFor(() => expect(progress.value.status).toBe("Done"));
+ });
+
+ it("advances after a confirmed pre-invoke listener failure instead of keeping an unknown lease", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { SnapshotCompletionError } = await import("@/lib/export/snapshotCompletion");
+ mocks.start.mockRejectedValueOnce(new SnapshotCompletionError("failed", "listener unavailable"));
+ const grid = useDataGridExport(fixture().options);
+ await grid.exportCsv();
+ await grid.exportCsv();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ expect(useExportTracker().tasks.value[0]!.status).toBe("Error");
+ expect(useExportTracker().tasks.value[0]!.errorMessage).toBe("listener unavailable");
+ finish(0);
+ });
+
+ it("cancels a waiting file without starting a backend export", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { options, progress } = fixture();
+ const grid = useDataGridExport(options);
+ await grid.exportCsv();
+ await grid.exportCsv();
+ expect(progress.value.status).toBe("Queued");
+ await options.exportCancelHandler!.value!();
+ expect(progress.value.status).toBe("Cancelled");
+ await options.exportCancelHandler!.value?.();
+ const { useExportTracker } = await import("../useExportTracker");
+ await useExportTracker().cancelTask(useExportTracker().tasks.value[1]!.exportId);
+ expect(mocks.cancel).not.toHaveBeenCalled();
+ finish(0);
+ await Promise.resolve();
+ expect(pending).toHaveLength(1);
+ });
+
+ it("waits for actual terminal progress after cancellation, not just the cancel response", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { options } = fixture();
+ const grid = useDataGridExport(options);
+ await grid.exportCsv();
+ await grid.exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(mocks.cancel).toHaveBeenCalledOnce();
+ expect(pending).toHaveLength(1);
+ finish(0, "Cancelled");
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ finish(1);
+ await Promise.resolve();
+ });
+
+ it("keeps the queue blocked when the started export loses its terminal result", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { options } = fixture();
+ const grid = useDataGridExport(options);
+ await grid.exportCsv();
+ await grid.exportCsv();
+ pending[0]!.reject(new Error("native connection interrupted"));
+ await vi.waitFor(() => expect(useExportTracker().tasks.value[0]!.status).toBe("Unknown"));
+ expect(pending).toHaveLength(1);
+ expect(useExportTracker().tasks.value[1]!.status).toBe("Queued");
+ });
+
+ it("does not start a cancelled export after its pending connection preparation finishes", async () => {
+ let connected!: () => void;
+ mocks.ensure.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ connected = resolve;
+ }),
+ );
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { options } = fixture();
+ const grid = useDataGridExport(options);
+ await grid.exportCsv();
+ await grid.exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelling");
+ expect(mocks.cancel).not.toHaveBeenCalled();
+ expect(pending).toHaveLength(0);
+ connected();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelled");
+ expect(pending[0]!.request.filePath).toBe("C:/exports/report-2.csv");
+ finish(0);
+ await Promise.resolve();
+ });
+
+ it("continues after a confirmed backend error without retrying the failed file", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { options } = fixture();
+ const grid = useDataGridExport(options);
+ await grid.exportCsv();
+ await grid.exportCsv();
+ const failed = pending[0]!;
+ failed.progress({ exportId: failed.request.exportId, tableName: "ORDERS", rowsExported: 0, totalRows: null, status: "Error", errorMessage: "permission denied" });
+ failed.reject(new Error("permission denied"));
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ expect(useExportTracker().tasks.value[0]!.status).toBe("Error");
+ expect(pending[1]!.request.filePath).toBe("C:/exports/report-2.csv");
+ finish(1);
+ await Promise.resolve();
+ });
+
+ function queryFixture() {
+ const result = fixture();
+ const querySql = ref("SELECT ID FROM ORIGINAL_QUERY");
+ const builders: Array<ReturnType<typeof vi.fn>> = [];
+ result.options.context = computed(() => "results");
+ result.options.sql = computed(() => querySql.value);
+ result.options.queryResultExportRequest = vi.fn(async () => {
+ throw new Error("active source callback must not be used for queued requests");
+ });
+ result.options.captureQueryResultExportRequest = () => {
+ const capturedSql = querySql.value;
+ const database = result.source.database;
+ const schema = result.source.schema;
+ const build = vi.fn(async (options) => ({ ...options, connectionId: "oracle-1", database, schema, databaseType: "oracle", sql: capturedSql, queryBaseSql: capturedSql, executionId: `execution-${options.exportId}` }));
+ builders.push(build);
+ return build;
+ };
+ return { ...result, querySql, builders };
+ }
+
+ it("keeps queued query preparation behind table exports and consumes the captured request only", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const query = queryFixture();
+ await useDataGridExport(query.options).exportCsv();
+ expect(query.builders).toHaveLength(2);
+ expect(query.builders.every((builder) => builder.mock.calls.length === 0)).toBe(true);
+ query.querySql.value = "SELECT SECRET FROM NEW_QUERY";
+ query.source.database = "OTHER_DATABASE";
+ query.source.schema = "PRIVATE";
+ finish(0);
+ await vi.waitFor(() => expect(mocks.queryStart).toHaveBeenCalledOnce());
+ expect(pending[1]!.request).toEqual(expect.objectContaining({ database: "XE", schema: "HR", sql: "SELECT ID FROM ORIGINAL_QUERY", filePath: "C:/exports/report-2.csv" }));
+ expect(query.builders[0]).not.toHaveBeenCalled();
+ expect(query.builders[1]).toHaveBeenCalledOnce();
+ expect(query.options.queryResultExportRequest).not.toHaveBeenCalled();
+ finish(1);
+ await Promise.resolve();
+ });
+
+ it("cancels a running query using its captured execution id and waits for terminal cleanup", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(queryFixture().options).exportCsv();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ await useDataGridExport(fixture().options).exportCsv();
+ const task = useExportTracker().tasks.value[0]!;
+ await useExportTracker().cancelTask(task.exportId);
+ expect(mocks.queryCancel).toHaveBeenCalledWith(task.exportId, `execution-${task.exportId}`);
+ expect(mocks.cancel).not.toHaveBeenCalled();
+ expect(pending).toHaveLength(1);
+ finish(0, "Cancelled");
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ finish(1);
+ await Promise.resolve();
+ });
+
+ function lobFixture(formatted = false) {
+ const result = fixture();
+ const snapshot = ref<QueryResult>({
+ columns: ["ID"],
+ column_types: ["CLOB"],
+ rows: [["preview"]],
+ affected_rows: 0,
+ execution_time_ms: 0,
+ large_value_cells: [{ row_index: 0, column_index: 0, original_bytes: 10, value_ref: "original-lob" }],
+ large_value_context: { connectionId: "oracle-1", database: "XE" },
+ });
+ const formatter = ref("original");
+ result.options.context = computed(() => "results");
+ result.options.columnTypes = computed(() => ["CLOB"]);
+ result.options.snapshotResult = computed(() => snapshot.value);
+ result.options.completeLocalResult = computed(() => snapshot.value);
+ result.options.hasCompleteLocalResult = computed(() => true);
+ result.options.hasColumnFormatter = () => formatted;
+ result.options.applyColumnFormattersOnExport = computed(() => true);
+ result.options.displayValue = (value) => `${formatter.value}:${value}`;
+ result.options.captureColumnFormatterDisplay = () => {
+ const pattern = formatter.value;
+ return (value) => `${pattern}:${value}`;
+ };
+ return { ...result, snapshot, formatter };
+ }
+
+ it.each(["exportCsv", "exportJson", "exportMarkdown", "exportHtml", "exportTxt"] as const)("defers captured legacy values for %s and keeps the original formatter", async (method) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const legacy = lobFixture(true);
+ delete legacy.snapshot.value.large_value_cells![0]!.value_ref;
+ const read = vi.fn().mockResolvedValue(new Map([[0, new Map([[0, "complete original"]])]]));
+ const capture = vi.fn(() => read);
+ legacy.options.captureSourceValues = capture;
+ await useDataGridExport(legacy.options)[method]();
+ expect(capture).toHaveBeenCalledWith([expect.objectContaining({ rowId: 0, sourceIndex: 0, columnIndex: 0 })]);
+ expect(read).not.toHaveBeenCalled();
+ legacy.snapshot.value = { ...legacy.snapshot.value, rows: [["new preview"]] };
+ legacy.source.connection = "other";
+ legacy.formatter.value = "changed";
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(read).toHaveBeenCalledOnce();
+ expect(JSON.stringify(mocks.memoryWrite.mock.calls[0])).toContain("original:complete original");
+ expect(mocks.readChunk).not.toHaveBeenCalled();
+ });
+
+ it.each(["exportSql", "exportXlsx"] as const)("resolves captured legacy values before %s and preserves format semantics", async (method) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const legacy = lobFixture(true);
+ legacy.options.hasUniqueQueryInsertTarget = computed(() => true);
+ legacy.options.currentResultLabel = computed(() => legacy.source.table);
+ delete legacy.snapshot.value.large_value_cells![0]!.value_ref;
+ const read = vi.fn().mockResolvedValue(new Map([[0, new Map([[0, "complete original"]])]]));
+ legacy.options.captureSourceValues = () => read;
+ await useDataGridExport(legacy.options)[method]();
+ expect(read).not.toHaveBeenCalled();
+ legacy.source.table = "OTHER";
+ legacy.source.schema = "PRIVATE";
+ legacy.formatter.value = "changed";
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(read).toHaveBeenCalledOnce();
+ if (method === "exportSql") {
+ expect(mocks.buildInsert).toHaveBeenCalledWith(expect.objectContaining({ schema: "HR", tableName: "ORDERS", rows: [["complete original"]] }));
+ } else {
+ expect(mocks.memoryWrite.mock.calls[0]![5]).toEqual([["original:complete original"]]);
+ }
+ expect(legacy.snapshot.value.rows).toEqual([["preview"]]);
+ expect(mocks.readChunk).not.toHaveBeenCalled();
+ });
+
+ it.each(["exportCsv", "exportJson", "exportMarkdown", "exportHtml", "exportTxt"] as const)("queues captured full-provider data for %s without calling the active provider", async (method) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const partial = lobFixture(true);
+ partial.options.hasCompleteLocalResult = computed(() => false);
+ const activeProvider = vi.fn();
+ const read = vi.fn().mockResolvedValue({ columns: ["ID"], column_types: ["CLOB"], rows: [["full original"]], has_more: false, truncated: false, execution_time_ms: 0, affected_rows: 0 });
+ const capture = vi.fn(() => read);
+ partial.options.fullExportResult = activeProvider;
+ partial.options.captureFullExportResult = capture;
+ await useDataGridExport(partial.options)[method]();
+ expect(capture).toHaveBeenCalledOnce();
+ expect(read).not.toHaveBeenCalled();
+ partial.source.connection = "other";
+ partial.formatter.value = "changed";
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(activeProvider).not.toHaveBeenCalled();
+ expect(read.mock.calls[0]![1].signal).toBeInstanceOf(AbortSignal);
+ expect(JSON.stringify(mocks.memoryWrite.mock.calls[0])).toContain("original:full original");
+ });
+
+ it.each(["exportSql", "exportXlsx"] as const)("uses captured target and returned full metadata for %s", async (method) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const partial = lobFixture(true);
+ partial.options.hasUniqueQueryInsertTarget = computed(() => true);
+ partial.options.hasCompleteLocalResult = computed(() => false);
+ partial.options.currentResultLabel = computed(() => partial.source.table);
+ const read = vi.fn().mockResolvedValue({ columns: ["ID", "BODY"], column_types: ["NUMBER", "CLOB"], rows: [[7, "full original"]], has_more: false, execution_time_ms: 0, affected_rows: 0 });
+ partial.options.captureFullExportResult = () => read;
+ await useDataGridExport(partial.options)[method]();
+ expect(read).not.toHaveBeenCalled();
+ partial.source.table = "OTHER";
+ partial.source.schema = "PRIVATE";
+ partial.formatter.value = "changed";
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ if (method === "exportSql") expect(mocks.buildInsert).toHaveBeenCalledWith(expect.objectContaining({ schema: "HR", tableName: "ORDERS", columns: ["ID", "BODY"], columnTypes: ["NUMBER", "CLOB"], rows: [[7, "full original"]] }));
+ else {
+ expect(mocks.memoryWrite.mock.calls[0]![1]).toBe("ORDERS");
+ expect(mocks.memoryWrite.mock.calls[0]![2]).toEqual(["ID", "BODY"]);
+ expect(mocks.memoryWrite.mock.calls[0]![3]).toEqual(["NUMBER", "CLOB"]);
+ expect(mocks.memoryWrite.mock.calls[0]![5]).toEqual([["original:7", "full original"]]);
+ }
+ });
+
+ it("does not release a full-provider lease after a cancelled read rejects with unknown completion", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { SnapshotCompletionError } = await import("@/lib/export/snapshotCompletion");
+ const partial = lobFixture();
+ partial.options.hasCompleteLocalResult = computed(() => false);
+ let rejectRead!: (error: Error) => void;
+ const read = vi.fn<(progress?: unknown, control?: { signal: AbortSignal }) => Promise<never>>(
+ () =>
+ new Promise<never>((_resolve, reject) => {
+ rejectRead = reject;
+ }),
+ );
+ partial.options.captureFullExportResult = () => read;
+ await useDataGridExport(partial.options).exportCsv();
+ await vi.waitFor(() => expect(read).toHaveBeenCalledOnce());
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(read.mock.calls[0]![1]!.signal.aborted).toBe(true);
+ expect(pending).toHaveLength(0);
+ rejectRead(new SnapshotCompletionError("unknown", "transport lost"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe("Unknown"));
+ expect(pending).toHaveLength(0);
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ });
+
+ it("keeps a legacy read's unknown outcome when cancellation arrives first", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { SnapshotCompletionError } = await import("@/lib/export/snapshotCompletion");
+ const legacy = lobFixture();
+ delete legacy.snapshot.value.large_value_cells![0]!.value_ref;
+ let rejectRead!: (error: Error) => void;
+ const read = vi.fn(
+ () =>
+ new Promise<Map<number, Map<number, string>>>((_resolve, reject) => {
+ rejectRead = reject;
+ }),
+ );
+ legacy.options.captureSourceValues = () => read;
+ await useDataGridExport(legacy.options).exportCsv();
+ await vi.waitFor(() => expect(read).toHaveBeenCalledOnce());
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(pending).toHaveLength(0);
+ expect(mocks.cancelQuery).not.toHaveBeenCalled();
+ rejectRead(new SnapshotCompletionError("unknown", "transport lost"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe("Unknown"));
+ expect(pending).toHaveLength(0);
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ });
+
+ it("does not start a queued LOB read or write while another export owns the queue", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(fixture().options).exportCsv();
+ await useDataGridExport(lobFixture(true).options).exportCsv();
+ expect(reads).toHaveLength(0);
+ expect(snapshots).toHaveLength(0);
+ await useExportTracker().cancelTask(useExportTracker().tasks.value[1]!.exportId);
+ finish(0);
+ await Promise.resolve();
+ expect(reads).toHaveLength(0);
+ expect(snapshots).toHaveLength(0);
+ });
+
+ it("retains native LOB materialization after local abort and does not write cancelled values", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(lobFixture(true).options).exportCsv();
+ await vi.waitFor(() => expect(reads).toHaveLength(1));
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(mocks.cancelQuery).toHaveBeenCalledOnce();
+ expect(pending).toHaveLength(0);
+ reads[0]!.resolve({ status: "ok", data: "complete", next_offset: 8, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelled");
+ expect(snapshots).toHaveLength(0);
+ finish(0);
+ await Promise.resolve();
+ });
+
+ it("waits for a native snapshot write and reports real success if cancellation arrives after commit", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(lobFixture().options).exportCsv();
+ await vi.waitFor(() => expect(snapshots).toHaveLength(1));
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(pending).toHaveLength(0);
+ expect(mocks.snapshot.mock.calls[0]![2]).toBeUndefined();
+ snapshots[0]!.resolve();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ expect(tracker.tasks.value[0]!.status).toBe("Done");
+ finish(0);
+ await Promise.resolve();
+ });
+
+ it("uses the formatter captured before waiting rather than a changed grid formatter", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const lob = lobFixture(true);
+ await useDataGridExport(lob.options).exportCsv();
+ lob.formatter.value = "changed";
+ finish(0);
+ await vi.waitFor(() => expect(reads).toHaveLength(1));
+ reads[0]!.resolve({ status: "ok", data: "complete", next_offset: 8, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(snapshots).toHaveLength(1));
+ expect(snapshots[0]!.request.rows).toEqual([["original:complete"]]);
+ expect(snapshots[0]!.request.cells).toEqual([]);
+ snapshots[0]!.resolve();
+ await Promise.resolve();
+ });
+
+ it.each(["failed", "cancelled", "unknown"] as const)("uses confirmed snapshot %s without treating cancel acknowledgement as completion", async (status) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { SnapshotCompletionError } = await import("@/lib/export/snapshotCompletion");
+ await useDataGridExport(lobFixture().options).exportCsv();
+ await vi.waitFor(() => expect(snapshots).toHaveLength(1));
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(pending).toHaveLength(0);
+ snapshots[0]!.reject(new SnapshotCompletionError(status, "original disk/read failure"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe(status === "failed" ? "Error" : status === "cancelled" ? "Cancelled" : "Unknown"));
+ if (status === "unknown") {
+ expect(pending).toHaveLength(0);
+ await tracker.cancelTask(tracker.tasks.value[1]!.exportId);
+ } else {
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ finish(0);
+ }
+ });
+
+ it.each([false, true])("queues a plain selected column without resolving an excluded LOB (complete=%s)", async (complete) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = fixture();
+ const original = ref<QueryResult>({ columns: ["ID", "BODY"], column_types: ["NUMBER", "CLOB"], rows: [[7, "preview"]], affected_rows: 0, execution_time_ms: 0, large_value_cells: [{ row_index: 0, column_index: 1, original_bytes: 5000 }] });
+ memory.options.context = computed(() => "results");
+ memory.options.columns = computed(() => ["ID", "BODY"]);
+ memory.options.columnTypes = computed(() => ["NUMBER", "CLOB"]);
+ memory.options.sourceColumns = computed(() => ["ID", "BODY"]);
+ memory.options.snapshotResult = computed(() => original.value);
+ memory.options.completeLocalResult = computed(() => (complete ? original.value : undefined));
+ memory.options.hasCompleteLocalResult = computed(() => complete);
+ memory.options.displayItems = computed(() => [{ id: 1, sourceIndex: 0, data: [7, "preview"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "normal" }]);
+ const resolver = vi.fn();
+ memory.options.resolveSourceValues = resolver;
+ await useDataGridExport(memory.options).exportCsv({ rowIds: [1], columnIndexes: [0] });
+ expect(resolver).not.toHaveBeenCalled();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ memory.source.connection = "different";
+ original.value = { ...original.value, rows: [[999, "different"]] };
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(mocks.memoryWrite.mock.calls[0]!.slice(1, 3)).toEqual([["ID"], [[7]]]);
+ expect(mocks.readChunk).not.toHaveBeenCalled();
+ });
+
+ it.each(["exportCsv", "exportJson", "exportMarkdown", "exportHtml", "exportTxt"] as const)("queues %s complete memory values without requerying or reading changed data", async (method) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = fixture();
+ const original = ref<QueryResult>({ columns: ["ID"], column_types: ["NUMBER"], rows: [[7], [8]], affected_rows: 0, execution_time_ms: 0 });
+ memory.options.context = computed(() => "results");
+ memory.options.hasCompleteLocalResult = computed(() => true);
+ memory.options.completeLocalResult = computed(() => original.value);
+ const provider = vi.fn();
+ memory.options.fullExportResult = provider;
+ await useDataGridExport(memory.options)[method]();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ original.value.rows[0]![0] = 999;
+ original.value = { ...original.value, rows: [[123]] };
+ memory.source.database = "OTHER";
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ const args = mocks.memoryWrite.mock.calls[0]!;
+ if (method === "exportTxt") {
+ expect(args[1]).toContain("7");
+ expect(args[1]).not.toContain("999");
+ } else expect(args[method === "exportHtml" ? 3 : 2]).toEqual([[7], [8]]);
+ expect(provider).not.toHaveBeenCalled();
+ expect(mocks.start).toHaveBeenCalledTimes(1);
+ expect(mocks.queryStart).not.toHaveBeenCalled();
+ });
+
+ it.each([false, true])("captures workbook rows, sheet title and included SQL before waiting (SQL sheet: %s)", async (includeSql) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = fixture();
+ const original = ref<QueryResult>({ columns: ["ID"], column_types: ["NUMBER"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 });
+ const sourceSql = ref("SELECT 7 FROM dual");
+ const label = ref("Original sheet");
+ memory.options.sql = computed(() => sourceSql.value);
+ memory.options.currentResultLabel = computed(() => label.value);
+ memory.options.context = computed(() => "results");
+ memory.options.hasCompleteLocalResult = computed(() => true);
+ memory.options.completeLocalResult = computed(() => original.value);
+ const grid = useDataGridExport(memory.options);
+ if (includeSql) await grid.exportXlsxWithSql();
+ else await grid.exportXlsx();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ sourceSql.value = "SELECT secret FROM other_schema";
+ label.value = "Other sheet";
+ original.value.rows[0]![0] = 999;
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ const args = mocks.memoryWrite.mock.calls[0]!;
+ if (includeSql) {
+ expect(args[1][0]).toEqual(expect.objectContaining({ sheetName: "Original sheet", rows: [[7]] }));
+ expect(JSON.stringify(args[1][1])).toContain("SELECT 7 FROM dual");
+ expect(JSON.stringify(args[1][1])).not.toContain("secret");
+ } else {
+ expect(args[1]).toBe("Original sheet");
+ expect(args[5]).toEqual([[7]]);
+ }
+ });
+
+ it("captures the SQL insert target and data while postponing generation and file writing", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = fixture();
+ const original = ref<QueryResult>({ columns: ["ID"], column_types: ["NUMBER"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 });
+ memory.options.context = computed(() => "results");
+ memory.options.hasUniqueQueryInsertTarget = computed(() => true);
+ memory.options.hasCompleteLocalResult = computed(() => true);
+ memory.options.completeLocalResult = computed(() => original.value);
+ mocks.sqlMode.mockResolvedValue({ insertMode: "single", executionMode: "queued" });
+ await useDataGridExport(memory.options).exportSql();
+ expect(mocks.mode).toHaveBeenCalledTimes(1);
+ expect(mocks.buildInsert).not.toHaveBeenCalled();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ memory.source.table = "OTHER";
+ memory.source.schema = "PRIVATE";
+ original.value.rows[0]![0] = 999;
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(mocks.buildInsert).toHaveBeenCalledWith(expect.objectContaining({ tableName: "ORDERS", schema: "HR", columns: ["ID"], columnTypes: ["NUMBER"], rows: [[7]], batchSize: 1 }));
+ expect(mocks.memoryWrite.mock.calls[0]![1]).toBe("INSERT original captured SQL");
+ });
+
+ it.each([false, true])("queues all memory result sheets as one captured workbook (SQL sheet: %s)", async (includeSql) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = fixture();
+ const sheets = ref([
+ { sheetName: "First", sql: "SELECT 7 FROM dual", result: { columns: ["ID"], column_types: ["NUMBER"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 } },
+ { sheetName: "Second", sql: "SELECT 8 FROM dual", result: { columns: ["ID"], column_types: ["NUMBER"], rows: [[8]], affected_rows: 0, execution_time_ms: 0 } },
+ ]);
+ memory.options.allExportResults = computed(() => sheets.value);
+ const grid = useDataGridExport(memory.options);
+ if (includeSql) await grid.exportAllResultsXlsxWithSql();
+ else await grid.exportAllResultsXlsx();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ sheets.value[0]!.sheetName = "Changed";
+ sheets.value[0]!.sql = "SELECT secret FROM other_schema";
+ sheets.value[0]!.result.rows[0]![0] = 999;
+ sheets.value = [];
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ const exported = mocks.memoryWrite.mock.calls[0]![1];
+ expect(exported).toHaveLength(includeSql ? 3 : 2);
+ expect(exported[0]).toEqual(expect.objectContaining({ sheetName: "First", rows: [[7]] }));
+ expect(exported[1]).toEqual(expect.objectContaining({ sheetName: "Second", rows: [[8]] }));
+ if (includeSql) {
+ expect(JSON.stringify(exported[2])).toContain("SELECT 7 FROM dual");
+ expect(JSON.stringify(exported[2])).not.toContain("secret");
+ }
+ });
+
+ it("cancels an entire queued memory workbook without generating or writing child sheets", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = fixture();
+ memory.options.allExportResults = computed(() => [{ sheetName: "First", result: { columns: ["ID"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 } }]);
+ await useDataGridExport(memory.options).exportAllResultsXlsx();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[1]!.exportId);
+ finish(0);
+ await Promise.resolve();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ expect(tracker.tasks.value[1]!.status).toBe("Cancelled");
+ });
+
+ it.each(["xlsx", "html"] as const)("counts %s memory writes as immediate without another execution-mode prompt", async (format) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = fixture();
+ memory.options.context = computed(() => "results");
+ memory.options.hasCompleteLocalResult = computed(() => true);
+ memory.options.completeLocalResult = computed(() => ({ columns: ["ID"], column_types: ["NUMBER"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 }));
+ let finishWrite!: () => void;
+ let finishOpen!: () => void;
+ mocks.memoryWrite.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finishWrite = resolve;
+ }),
+ );
+ mocks.openTemp.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finishOpen = resolve;
+ }),
+ );
+ const grid = useDataGridExport(memory.options);
+ const opening = format === "xlsx" ? grid.openXlsx() : grid.exportHtml(undefined, true);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(mocks.mode).toHaveBeenCalledOnce();
+ expect(mocks.createTemp).toHaveBeenCalledWith(format);
+ await useDataGridExport(fixture().options).exportCsv();
+ finish(0);
+ expect(pending).toHaveLength(1);
+ finishWrite();
+ await vi.waitFor(() => expect(mocks.openTemp).toHaveBeenCalledOnce());
+ expect(pending).toHaveLength(1);
+ finishOpen();
+ await opening;
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ finish(1);
+ });
+
+ it("captures each legacy sheet before waiting and writes only resolved private rows", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const legacy: QueryResult = { columns: ["ID", "BODY"], rows: [[7, "preview"]], large_value_cells: [{ row_index: 0, column_index: 1, original_bytes: 100 }], affected_rows: 0, execution_time_ms: 0 };
+ let resolveRead!: (values: Map<number, Map<number, string>>) => void;
+ const read = vi.fn(
+ () =>
+ new Promise<Map<number, Map<number, string>>>((resolve) => {
+ resolveRead = resolve;
+ }),
+ );
+ const capture = vi.fn(() => ({ read }));
+ const memory = fixture();
+ await useDataGridExport(memory.options).exportResultSheetsXlsx([
+ { sheetName: "Plain", result: { columns: ["ID"], rows: [[1]], affected_rows: 0, execution_time_ms: 0 } },
+ { sheetName: "Other table", result: legacy, captureSourceValues: capture },
+ ]);
+ expect(capture).toHaveBeenCalledOnce();
+ expect(read).not.toHaveBeenCalled();
+ await useDataGridExport(fixture().options).exportCsv();
+ finish(0);
+ await vi.waitFor(() => expect(read).toHaveBeenCalledOnce());
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ expect(pending).toHaveLength(1);
+ resolveRead(new Map([[0, new Map([[1, "complete body"]])]]));
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(mocks.memoryWrite.mock.calls[0]![1]).toEqual([expect.objectContaining({ sheetName: "Plain", rows: [[1]] }), expect.objectContaining({ sheetName: "Other table", rows: [[7, "complete body"]] })]);
+ expect(legacy.rows).toEqual([[7, "preview"]]);
+ expect(legacy.large_value_cells).toHaveLength(1);
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ finish(1);
+ });
+
+ it("fails the whole legacy workbook before reading any sheet when a source is unavailable", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const legacy: QueryResult = { columns: ["BODY"], rows: [["preview"]], large_value_cells: [{ row_index: 0, column_index: 0, original_bytes: 100 }], affected_rows: 0, execution_time_ms: 0 };
+ const read = vi.fn();
+ await useDataGridExport(fixture().options).exportResultSheetsXlsx([
+ { sheetName: "Known", result: legacy, captureSourceValues: () => ({ read }) },
+ { sheetName: "Unknown", result: legacy },
+ ]);
+ await vi.waitFor(() => expect(useExportTracker().tasks.value[0]!.status).toBe("Error"));
+ expect(useExportTracker().tasks.value[0]!.errorMessage).toContain("Unknown:");
+ expect(read).not.toHaveBeenCalled();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ await useDataGridExport(fixture().options).exportCsv();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ finish(0);
+ });
+
+ it.each(["completed", "unknown"] as const)("waits for the legacy sheet read after cancellation and preserves %s completion", async (completion) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { SnapshotCompletionError } = await import("@/lib/export/snapshotCompletion");
+ let resolveRead!: (values: Map<number, Map<number, string>>) => void;
+ let rejectRead!: (error: Error) => void;
+ const read = vi.fn(
+ () =>
+ new Promise<Map<number, Map<number, string>>>((resolve, reject) => {
+ resolveRead = resolve;
+ rejectRead = reject;
+ }),
+ );
+ await useDataGridExport(fixture().options).exportResultSheetsXlsx([
+ { sheetName: "Legacy", result: { columns: ["BODY"], rows: [["preview"]], large_value_cells: [{ row_index: 0, column_index: 0, original_bytes: 100 }], affected_rows: 0, execution_time_ms: 0 }, captureSourceValues: () => ({ read }) },
+ ]);
+ await vi.waitFor(() => expect(read).toHaveBeenCalledOnce());
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelling");
+ expect(mocks.cancelQuery).not.toHaveBeenCalled();
+ expect(pending).toHaveLength(0);
+ if (completion === "unknown") rejectRead(new SnapshotCompletionError("unknown", "read reply unavailable"));
+ else resolveRead(new Map([[0, new Map([[0, "complete"]])]]));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe(completion === "unknown" ? "Unknown" : "Cancelled"));
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ if (completion === "completed") {
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ finish(0);
+ } else expect(pending).toHaveLength(0);
+ });
+
+ it("holds one workbook lease across both LOB sheets and the actual file write", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(fixture().options).exportCsv();
+ const lob = lobFixture();
+ const second: QueryResult = { ...lob.snapshot.value, rows: [["second preview"]], large_value_cells: [{ row_index: 0, column_index: 0, original_bytes: 10, value_ref: "second-lob" }] };
+ const sheets = ref([
+ { sheetName: "First", result: lob.snapshot.value },
+ { sheetName: "Second", result: second },
+ ]);
+ lob.options.allExportResults = computed(() => sheets.value);
+ let finishWrite!: () => void;
+ mocks.memoryWrite.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finishWrite = resolve;
+ }),
+ );
+ await useDataGridExport(lob.options).exportAllResultsXlsx();
+ expect(reads).toHaveLength(0);
+ await useDataGridExport(fixture().options).exportCsv();
+ sheets.value[0]!.sheetName = "Changed";
+ finish(0);
+ await vi.waitFor(() => expect(reads).toHaveLength(1));
+ expect(pending).toHaveLength(1);
+ reads[0]!.resolve({ status: "ok", data: "first complete", next_offset: 14, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(reads).toHaveLength(2));
+ expect(mocks.readChunk.mock.calls[1]![0]).toMatchObject({ valueRef: "second-lob" });
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ reads[1]!.resolve({ status: "ok", data: "second complete", next_offset: 15, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(mocks.memoryWrite.mock.calls[0]![1]).toEqual([expect.objectContaining({ sheetName: "First", rows: [["first complete"]] }), expect.objectContaining({ sheetName: "Second", rows: [["second complete"]] })]);
+ expect(useExportTracker().tasks.value[1]!.canCancel).toBe(false);
+ expect(pending).toHaveLength(1);
+ finishWrite();
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ finish(1);
+ });
+
+ it.each(["completed", "unknown"] as const)("waits for a cancelled LOB workbook block and preserves %s completion", async (completion) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ const { SnapshotCompletionError } = await import("@/lib/export/snapshotCompletion");
+ const lob = lobFixture();
+ lob.options.allExportResults = computed(() => [
+ { sheetName: "First", result: lob.snapshot.value },
+ { sheetName: "Second", result: lob.snapshot.value },
+ ]);
+ let rejectRead!: (error: Error) => void;
+ if (completion === "unknown")
+ mocks.readChunk.mockImplementationOnce(
+ () =>
+ new Promise((_resolve, reject) => {
+ rejectRead = reject;
+ }),
+ );
+ await useDataGridExport(lob.options).exportAllResultsXlsx();
+ await vi.waitFor(() => expect(mocks.readChunk).toHaveBeenCalledOnce());
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(pending).toHaveLength(0);
+ if (completion === "unknown") rejectRead(new SnapshotCompletionError("unknown", "transport lost"));
+ else reads[0]!.resolve({ status: "ok", data: "complete", next_offset: 8, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe(completion === "unknown" ? "Unknown" : "Cancelled"));
+ expect(mocks.readChunk).toHaveBeenCalledOnce();
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ if (completion === "completed") {
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ finish(0);
+ } else expect(pending).toHaveLength(0);
+ });
+
+ it.each(["exportXlsx", "exportMarkdown", "exportHtml", "exportTxt", "exportSql"] as const)("queues complete LOB materialization for %s before writing", async (method) => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const lob = lobFixture(method === "exportXlsx" || method === "exportSql");
+ await useDataGridExport(lob.options)[method]();
+ expect(reads).toHaveLength(0);
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ lob.formatter.value = "changed";
+ finish(0);
+ await vi.waitFor(() => expect(reads).toHaveLength(1));
+ expect(mocks.readChunk.mock.calls[0]![1]).toBe(true);
+ reads[0]!.resolve({ status: "ok", data: "complete", next_offset: 8, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ const args = mocks.memoryWrite.mock.calls[0]!;
+ if (method === "exportXlsx") expect(args[5]).toEqual([["original:complete"]]);
+ else if (method === "exportHtml") expect(args[3]).toEqual([["complete"]]);
+ else if (method === "exportMarkdown") expect(args[2]).toEqual([["complete"]]);
+ else if (method === "exportTxt") expect(args[1]).toContain("complete");
+ else expect(mocks.buildInsert).toHaveBeenCalledWith(expect.objectContaining({ rows: [["complete"]] }));
+ expect(snapshots).toHaveLength(0);
+ });
+
+ it("retains an unformatted XLSX LOB read after cancellation until the original response returns", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(lobFixture().options).exportXlsx();
+ await vi.waitFor(() => expect(reads).toHaveLength(1));
+ await useDataGridExport(fixture().options).exportCsv();
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(pending).toHaveLength(0);
+ reads[0]!.resolve({ status: "ok", data: "complete", next_offset: 8, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelled");
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ finish(0);
+ });
+
+ it("finishes a known XLSX cell-length failure without writing, then permits the next queued export", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ await useDataGridExport(fixture().options).exportCsv();
+ mocks.readChunk.mockImplementation(async (request) => ({ status: "ok", data: "x".repeat(4096), next_offset: request.offset + 4096, eof: request.offset + 4096 === 32768, value_kind: "text" }));
+ await useDataGridExport(lobFixture().options).exportXlsx();
+ await useDataGridExport(fixture().options).exportCsv();
+ finish(0);
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ expect(useExportTracker().tasks.value[1]!.status).toBe("Error");
+ expect(mocks.memoryWrite).not.toHaveBeenCalled();
+ expect(mocks.readChunk).toHaveBeenCalledTimes(8);
+ finish(1);
+ });
+
+ it("disables cancellation while a native workbook writer runs and holds the lease until it returns", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ const { useExportTracker } = await import("../useExportTracker");
+ let finishWrite!: () => void;
+ mocks.memoryWrite.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finishWrite = resolve;
+ }),
+ );
+ const lob = lobFixture();
+ await useDataGridExport(lob.options).exportXlsx();
+ await vi.waitFor(() => expect(reads).toHaveLength(1));
+ await useDataGridExport(fixture().options).exportCsv();
+ reads[0]!.resolve({ status: "ok", data: "complete", next_offset: 8, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(useExportTracker().tasks.value[0]!.canCancel).toBe(false);
+ expect(lob.options.exportCancelHandler!.value).toBeNull();
+ expect(pending).toHaveLength(0);
+ finishWrite();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ expect(useExportTracker().tasks.value[0]!.status).toBe("Done");
+ finish(0);
+ });
+
+ it("opens a LOB workbook immediately without another mode prompt while retaining its execution lease", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ let finishWrite!: () => void;
+ mocks.memoryWrite.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ finishWrite = resolve;
+ }),
+ );
+ const opening = useDataGridExport(lobFixture().options).openXlsx();
+ await vi.waitFor(() => expect(reads).toHaveLength(1));
+ expect(mocks.mode).toHaveBeenCalledTimes(1);
+ expect(mocks.createTemp).toHaveBeenCalledWith("xlsx");
+ await useDataGridExport(fixture().options).exportCsv();
+ finish(0);
+ await Promise.resolve();
+ expect(pending).toHaveLength(1);
+ reads[0]!.resolve({ status: "ok", data: "complete", next_offset: 8, eof: true, value_kind: "text" });
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(pending).toHaveLength(1);
+ finishWrite();
+ await opening;
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ expect(mocks.openTemp).toHaveBeenCalledWith("C:/exports/temp.xlsx");
+ finish(1);
+ });
+
+ it("queues already materialized values even when the result retains old locator references", async () => {
+ const { useDataGridExport } = await import("../useDataGridExport");
+ await useDataGridExport(fixture().options).exportCsv();
+ const memory = lobFixture();
+ memory.snapshot.value.rows = [["hydrated complete value"]];
+ memory.snapshot.value.large_value_cells = [];
+ memory.snapshot.value.large_value_refs = ["retired-locator"];
+ await useDataGridExport(memory.options).exportCsv();
+ memory.source.connection = "other-connection";
+ finish(0);
+ await vi.waitFor(() => expect(mocks.memoryWrite).toHaveBeenCalledOnce());
+ expect(mocks.memoryWrite.mock.calls[0]![2]).toEqual([["hydrated complete value"]]);
+ expect(mocks.readChunk).not.toHaveBeenCalled();
+ expect(mocks.snapshot).not.toHaveBeenCalled();
+ expect(mocks.ensure).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.ts
index 3bd6f7b874..222e9fc99d 100644
--- a/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataGridExport.sqlColumns.spec.ts
@@ -13,6 +13,7 @@ import { DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS } from "@/lib/dataGrid/dataGridCopy
const mocks = vi.hoisted(() => ({ native: true, toast: vi.fn() }));
vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => mocks.native }));
vi.mock("@tauri-apps/plugin-dialog", () => ({ save: vi.fn().mockResolvedValue("/exports/result.sql") }));
+vi.mock("@tauri-apps/plugin-fs", () => ({ writeTextFile: vi.fn().mockResolvedValue(undefined) }));
vi.mock("@/lib/backend/api", () => ({ startQueryResultExport: vi.fn(), startTableExport: vi.fn(), cancelQueryResultExport: vi.fn(), cancelTableExport: vi.fn() }));
vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
vi.mock("@/composables/useDataGridExtractor", () => ({ useDataGridExtractor: () => ({ copyWithExtractor: vi.fn(), previewWithExtractor: vi.fn(), canCopyWithExtractor: vi.fn() }) }));
@@ -85,8 +86,8 @@ describe("SQL export column selection across entrypoints", () => {
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "single", selectedColumns: [choices[2]!] });
const state = useDataGridExport(createOptions({ allColumns: computed(() => ["id", "name", "id"]), allColumnTypes: computed(() => ["int", "text", "bigint"]) }));
await state.exportSql();
- expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: choices });
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ selectedColumns: [choices[2]!], exportColumnTypes: ["int", "text", "bigint"], insertMode: "single", keysetOptimizationEnabled: true, sql: "SELECT id, name FROM users" }), expect.any(Function));
+ expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ showExecutionMode: true, allowSplit: false, columns: choices });
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ selectedColumns: [choices[2]!], exportColumnTypes: ["int", "text", "bigint"], insertMode: "single", keysetOptimizationEnabled: true, sql: "SELECT id, name FROM users" }), expect.any(Function), true);
});
it("excludes only the exact PostgreSQL primary-key spelling", async () => {
@@ -114,14 +115,14 @@ describe("SQL export column selection across entrypoints", () => {
await state.exportSql();
- expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: choices.filter((column) => column.name !== "id") });
+ expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ showExecutionMode: true, allowSplit: false, columns: choices.filter((column) => column.name !== "id") });
});
it("preserves full table paging keys and split options in the backend request", async () => {
const selectedColumns = [sqlExportColumnChoices(["id", "name"])[1]!];
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "batch", selectedColumns, splitMaxMb: 128 });
await useDataGridExport(createOptions({ context: computed(() => "table-data") })).exportSql();
- expect(api.startTableExport).toHaveBeenCalledWith(expect.objectContaining({ columns: ["id", "name"], columnTypes: ["int4", "text"], selectedColumns, splitMaxMb: 128 }), expect.any(Function));
+ expect(api.startTableExport).toHaveBeenCalledWith(expect.objectContaining({ columns: ["id", "name"], columnTypes: ["int4", "text"], selectedColumns, splitMaxMb: 128 }), expect.any(Function), true);
expect(api.startQueryResultExport).not.toHaveBeenCalled();
});
@@ -141,7 +142,7 @@ describe("SQL export column selection across entrypoints", () => {
extractorOptions: computed(() => ({ ...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS, sql: { ...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS.sql, primaryKeyMode: "exclude-generated" } })),
}),
).exportSql();
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ exportColumnExtras: ["identity", null, null], primaryKeys: ["id"], primaryKeyMode: "exclude-generated", selectedColumns: sqlExportColumnChoices(names) }), expect.any(Function));
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ exportColumnExtras: ["identity", null, null], primaryKeys: ["id"], primaryKeyMode: "exclude-generated", selectedColumns: sqlExportColumnChoices(names) }), expect.any(Function), true);
});
it.each(["page", "selected", "web"] as const)("does not re-exclude a projected case-distinct non-key in the %s fallback", async (scope) => {
@@ -241,7 +242,7 @@ describe("SQL export column selection across entrypoints", () => {
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "batch", selectedColumns: [choices[2]!, choices[3]!] });
const result = { columns: names, column_types: ["ROWID", "int", "bigint", "geometry"], rows: [["key", 1, 20, "POINT(1 2)"]], hidden_column_indexes: [0], spatial_columns: [{ column_index: 3, srid: 4326 }], spatial_values: [[null, null, null, 4326]] } as QueryResult;
await useDataGridExport(createOptions({ databaseType: computed(() => "oracle"), allColumns: computed(() => names), hasCompleteLocalResult: computed(() => true), completeLocalResult: computed(() => result) })).exportSql();
- expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: choices.slice(1) });
+ expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ showExecutionMode: true, allowSplit: false, columns: choices.slice(1) });
expect(formatSqlInsert).toHaveBeenCalledWith(expect.objectContaining({ columns: ["id", "shape"], columnTypes: ["bigint", "geometry"], rows: [[20, "POINT(1 2)"]], spatialColumns: [{ column_index: 1, srid: 4326 }], spatialValues: [[null, 4326]] }));
expect(api.startQueryResultExport).not.toHaveBeenCalled();
});
@@ -282,7 +283,7 @@ describe("SQL export column selection across entrypoints", () => {
})),
}),
).exportSql();
- expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: true, columns: sqlExportColumnChoices(names).filter((column) => column.name !== "generated") });
+ expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ showExecutionMode: true, allowSplit: true, columns: sqlExportColumnChoices(names).filter((column) => column.name !== "generated") });
});
it("prefers SQL Server table metadata types so non-insertable columns get filtered", async () => {
@@ -322,7 +323,7 @@ describe("SQL export column selection across entrypoints", () => {
it("omits PostgreSQL tsvector fields using query metadata", async () => {
vi.mocked(showSqlInsertModeDialog).mockResolvedValue(null);
await useDataGridExport(createOptions({ allColumns: computed(() => ["id", "search"]), allColumnTypes: computed(() => ["int", "pg_catalog.tsvector"]) })).exportSql();
- expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: sqlExportColumnChoices(["id"]) });
+ expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ showExecutionMode: true, allowSplit: false, columns: sqlExportColumnChoices(["id"]) });
});
it("does not export after cancellation or an invalid empty selection", async () => {
@@ -349,7 +350,7 @@ describe("SQL export column selection across entrypoints", () => {
}),
);
await state.exportSql({ columnIndexes: [0] });
- expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: choices });
+ expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ showExecutionMode: true, allowSplit: false, columns: choices });
});
it("keeps legacy omitted selection behavior", async () => {
diff --git a/apps/desktop/src/composables/__tests__/useDataGridExport.sqlProgress.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridExport.sqlProgress.spec.ts
index cd6ad923ce..7b8273d934 100644
--- a/apps/desktop/src/composables/__tests__/useDataGridExport.sqlProgress.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataGridExport.sqlProgress.spec.ts
@@ -142,7 +142,7 @@ describe("query result SQL export progress", () => {
expect(progressState.value.startedAt).toEqual(expect.any(Number));
expect(progressState.value.finishedAt).toEqual(expect.any(Number));
expect(cancelHandler.value).toBeNull();
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "sql", exportTableName: "users", exportColumnTypes: ["int4", "text"] }), expect.any(Function));
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "sql", exportTableName: "users", exportColumnTypes: ["int4", "text"] }), expect.any(Function), true);
});
it("passes a resolved Oracle owner as the INSERT target without changing query execution schema", async () => {
@@ -168,7 +168,7 @@ describe("query result SQL export progress", () => {
await state.exportSql();
expect(queryResultExportRequest).toHaveBeenCalledWith(expect.objectContaining({ exportTableName: "USERS", exportSchema: "APP_OWNER" }));
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ schema: "CURRENT_USER", exportSchema: "APP_OWNER", exportTableName: "USERS" }), expect.any(Function));
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ schema: "CURRENT_USER", exportSchema: "APP_OWNER", exportTableName: "USERS" }), expect.any(Function), true);
});
it("does not infer a target table for query results without a unique source", async () => {
@@ -195,7 +195,7 @@ describe("query result SQL export progress", () => {
await state.exportSql();
expect(queryResultExportRequest).toHaveBeenCalledWith(expect.objectContaining({ exportTableName: undefined, exportSchema: undefined }));
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ exportTableName: undefined, exportSchema: undefined }), expect.any(Function));
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ exportTableName: undefined, exportSchema: undefined }), expect.any(Function), true);
});
it("forwards result column EXTRA metadata so identity INSERT exports can be replayed", async () => {
@@ -214,7 +214,7 @@ describe("query result SQL export progress", () => {
await state.exportSql();
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "sql", exportColumnTypes: ["int4", "text"], exportColumnExtras: ["identity(1,1)", null] }), expect.any(Function));
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "sql", exportColumnTypes: ["int4", "text"], exportColumnExtras: ["identity(1,1)", null] }), expect.any(Function), true);
});
it("routes incomplete query-result JSON exports through the streaming backend", async () => {
@@ -222,7 +222,7 @@ describe("query result SQL export progress", () => {
await state.exportJson();
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "json", sql: "SELECT id, name FROM users" }), expect.any(Function));
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "json", sql: "SELECT id, name FROM users" }), expect.any(Function), true);
});
});
@@ -238,7 +238,7 @@ describe("open query result as XLSX", () => {
return progress;
});
await useDataGridExport(createOptions()).openXlsx();
- expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "xlsx", filePath: "/tmp/dbx-query-results/result.xlsx" }), expect.any(Function));
+ expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ format: "xlsx", filePath: "/tmp/dbx-query-results/result.xlsx" }), expect.any(Function), true);
if (status === "Done") expect(api.openQueryResultTempFile).toHaveBeenCalledWith("/tmp/dbx-query-results/result.xlsx");
else expect(api.openQueryResultTempFile).not.toHaveBeenCalled();
});
diff --git a/apps/desktop/src/composables/__tests__/useDataGridExport.xlsx.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridExport.xlsx.spec.ts
index 641f98bd44..b6916da383 100644
--- a/apps/desktop/src/composables/__tests__/useDataGridExport.xlsx.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataGridExport.xlsx.spec.ts
@@ -4,6 +4,7 @@ import { computed, ref } from "vue";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { useDataGridExport, type UseDataGridExportOptions } from "@/composables/useDataGridExport";
import type { QueryResult } from "@/types/database";
+import { useExportTracker } from "@/composables/useExportTracker";
const mocks = vi.hoisted(() => ({
exportQueryResultsXlsx: vi.fn(),
@@ -45,16 +46,6 @@ vi.mock("@/composables/useDataGridExtractor", () => ({
}),
}));
-vi.mock("@/composables/useExportTracker", () => ({
- useExportTracker: () => ({
- addTask: vi.fn(),
- updateTableExportTask: vi.fn(),
- registerTaskCancelHandler: vi.fn(),
- unregisterTaskCancelHandler: vi.fn(),
- removeTask: vi.fn(),
- }),
-}));
-
vi.mock("@/stores/settingsStore", () => ({
useSettingsStore: () => ({
editorSettings: {
@@ -121,6 +112,8 @@ function createOptions(): UseDataGridExportOptions {
describe("useDataGridExport XLSX headers", () => {
beforeEach(() => {
vi.clearAllMocks();
+ const tracker = useExportTracker();
+ for (const task of tracker.tasks.value) tracker.removeTask(task.exportId);
});
it("maps combined headers independently for every result sheet", async () => {
diff --git a/apps/desktop/src/composables/__tests__/useDataGridLargeValues.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridLargeValues.spec.ts
index b707b977ed..e5f7866ebc 100644
--- a/apps/desktop/src/composables/__tests__/useDataGridLargeValues.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useDataGridLargeValues.spec.ts
@@ -6,7 +6,7 @@ import { binaryCellDisplayText, binaryCellDownloadPayload } from "@/lib/dataGrid
import { useDataGridLargeValues } from "@/composables/useDataGridLargeValues";
import { useDataGridEditor } from "@/composables/useDataGridEditor";
import { createDataGridRuntimeScope } from "@/lib/dataGrid/dataGridRuntime";
-import type { DatabaseType, QueryResult } from "@/types/database";
+import type { ConnectionConfig, DatabaseType, QueryResult } from "@/types/database";
const mocks = vi.hoisted(() => ({
buildDataGridContextFilterCondition: vi.fn(),
@@ -43,6 +43,7 @@ afterEach(() => {
});
function mountLargeValues(databaseType: DatabaseType, result: Ref<QueryResult>, withEditor = false) {
+ const config = ref({ id: `${databaseType}-1`, name: "Test", db_type: databaseType, host: "original" } as ConnectionConfig);
const runtimeScope = createDataGridRuntimeScope();
const toast = vi.fn();
const formatCell = (value: unknown, columnIndex?: number, originalBytes?: number) => binaryCellDisplayText(value, result.value.column_types?.[columnIndex ?? 0], originalBytes, databaseType) ?? String(value ?? "");
@@ -79,7 +80,7 @@ function mountLargeValues(databaseType: DatabaseType, result: Ref<QueryResult>,
clearCellFormatCache: vi.fn(),
invalidateResultEstimate: vi.fn(),
connectionIdentifierQuote: () => '"',
- getConnectionConfig: () => undefined,
+ getConnectionConfig: () => config.value,
includeDatabaseName: computed(() => true),
globalQueryTimeoutSecs: computed(() => 30),
resultLifecycle: { beginOperation: () => 1, isCurrent: () => true },
@@ -132,7 +133,7 @@ function mountLargeValues(databaseType: DatabaseType, result: Ref<QueryResult>,
app.unmount();
});
if (!largeValues) throw new Error("useDataGridLargeValues was not mounted");
- return { largeValues, toast, item, editor, runtimeScope };
+ return { largeValues, toast, item, editor, runtimeScope, config };
}
function previewResult(columnType = "bytea", value = "\\x00017f80ff...", originalBytes = 9645) {
@@ -147,6 +148,110 @@ function previewResult(columnType = "bytea", value = "\\x00017f80ff...", origina
}
describe("useDataGridLargeValues", () => {
+ it.each(["metadata", "target"] as const)("uses target identity rather than incidental connection fields for legacy exports (%s)", async (change) => {
+ const result = previewResult();
+ const { largeValues, config } = mountLargeValues("postgres", result);
+ const run = largeValues.captureSourceValues([{ rowId: 1, sourceIndex: 0, columnIndex: 1 }]);
+ if (change === "metadata") Object.assign(config.value, { note: "updated note", default_schema: "other display schema", database_info: { product_name: "PostgreSQL" } });
+ else config.value.host = "other target";
+ mocks.buildDataGridContextFilterCondition.mockResolvedValue('"ID" = 1');
+ mocks.buildTableSelectSql.mockResolvedValue("original select");
+ mocks.executeMulti.mockResolvedValue([{ columns: ["ID", "APP"], rows: [[1, "complete"]] }]);
+ if (change === "metadata") expect((await run(new AbortController().signal)).get(1)?.get(1)).toBe("complete");
+ else {
+ await expect(run(new AbortController().signal)).rejects.toMatchObject({ status: "failed" });
+ expect(mocks.executeMulti).not.toHaveBeenCalled();
+ }
+ });
+ it("captures legacy PK values and columns before deferred export reads", async () => {
+ const result = previewResult();
+ const { largeValues } = mountLargeValues("postgres", result);
+ const run = largeValues.captureSourceValues([{ rowId: 1, sourceIndex: 0, columnIndex: 1 }]);
+ expect(mocks.executeMulti).not.toHaveBeenCalled();
+ result.value = { ...result.value, columns: ["NEW_ID", "OTHER"], rows: [[99, "different"]] };
+ mocks.buildDataGridContextFilterCondition.mockResolvedValue('"ID" = 1');
+ mocks.buildTableSelectSql.mockResolvedValue("original select");
+ mocks.executeMulti.mockResolvedValue([{ columns: ["ID", "APP"], rows: [[1, "complete"]] }]);
+ const values = await run(new AbortController().signal);
+ expect(mocks.buildDataGridContextFilterCondition).toHaveBeenCalledWith(expect.objectContaining({ columnName: "ID", value: 1 }));
+ expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ tableName: "APP_DATA", columns: ["ID", "APP"] }));
+ expect(mocks.executeMulti).toHaveBeenCalledWith("postgres-1", "MAXIMO", "original select", undefined, "execution-1", expect.objectContaining({ maxRows: 1 }));
+ expect(values.get(1)?.get(1)).toBe("complete");
+ });
+
+ it.each(["resolve", "reject"] as const)("waits for an in-flight legacy export read on cancellation (%s)", async (completion) => {
+ const result = previewResult();
+ const { largeValues } = mountLargeValues("postgres", result);
+ const controller = new AbortController();
+ mocks.buildDataGridContextFilterCondition.mockResolvedValue("ID = 1");
+ mocks.buildTableSelectSql.mockResolvedValue("select");
+ let resolveRead!: (value: unknown) => void;
+ let rejectRead!: (reason: Error) => void;
+ mocks.executeMulti.mockImplementation(
+ () =>
+ new Promise((resolve, reject) => {
+ resolveRead = resolve;
+ rejectRead = reject;
+ }),
+ );
+ const pending = largeValues.captureSourceValues([{ rowId: 1, sourceIndex: 0, columnIndex: 1 }])(controller.signal);
+ const outcome = pending.catch((error) => error);
+ await vi.waitFor(() => expect(mocks.executeMulti).toHaveBeenCalledOnce());
+ let finished = false;
+ void outcome.then(() => {
+ finished = true;
+ });
+ controller.abort();
+ await nextTick();
+ expect(finished).toBe(false);
+ expect(mocks.cancelQuery).not.toHaveBeenCalled();
+ if (completion === "resolve") resolveRead([{ columns: ["ID", "APP"], rows: [[1, "complete"]] }]);
+ else rejectRead(new Error("transport lost"));
+ expect(await outcome).toMatchObject({ status: completion === "resolve" ? "cancelled" : "unknown" });
+ });
+
+ it("keeps distinct quoted result names when resolving a captured legacy value", async () => {
+ const result = previewResult();
+ result.value.columns = ["ID", "id"];
+ const { largeValues } = mountLargeValues("postgres", result);
+ mocks.buildDataGridContextFilterCondition.mockResolvedValue('"ID" = 1');
+ mocks.buildTableSelectSql.mockResolvedValue('SELECT "ID", "id" FROM "APP_DATA"');
+ mocks.executeMulti.mockResolvedValue([{ columns: ["ID", "id"], rows: [[1, "complete"]] }]);
+ const resolved = await largeValues.captureSourceValues([{ rowId: 1, sourceIndex: 0, columnIndex: 1 }])(new AbortController().signal);
+ expect(resolved.get(1)?.get(1)).toBe("complete");
+ });
+
+ it.each(["duplicate_identity", "unknown_after_not_started"] as const)("rejects unsafe legacy export results (%s)", async (reason) => {
+ const result = previewResult();
+ const { largeValues } = mountLargeValues("postgres", result);
+ mocks.buildDataGridContextFilterCondition.mockResolvedValue("ID = 1");
+ mocks.buildTableSelectSql.mockResolvedValue("select");
+ const failed = { columns: ["message"], rows: [["failed"]], execution_error: true, error: { operationOutcome: "not_started" } };
+ mocks.executeMulti.mockResolvedValue(
+ reason === "duplicate_identity"
+ ? [
+ {
+ columns: ["ID", "APP"],
+ rows: [
+ [1, "first"],
+ [1, "second"],
+ ],
+ },
+ ]
+ : [failed, { ...failed, error: { operationOutcome: "unknown" } }],
+ );
+ await expect(largeValues.captureSourceValues([{ rowId: 1, sourceIndex: 0, columnIndex: 1 }])(new AbortController().signal)).rejects.toMatchObject({ status: reason === "duplicate_identity" ? "failed" : "unknown" });
+ });
+
+ it("rejects a legacy export result that still contains a preview", async () => {
+ const result = previewResult();
+ const { largeValues } = mountLargeValues("postgres", result);
+ mocks.buildDataGridContextFilterCondition.mockResolvedValue("ID = 1");
+ mocks.buildTableSelectSql.mockResolvedValue("select");
+ mocks.executeMulti.mockResolvedValue([result.value]);
+ await expect(largeValues.captureSourceValues([{ rowId: 1, sourceIndex: 0, columnIndex: 1 }])(new AbortController().signal)).rejects.toMatchObject({ status: "failed" });
+ });
+
it.each(["result", "locator", "clientSessionId", "txnSessionId", "catalog", "disposal"] as const)("rejects a captured download target after its %s changes", async (change) => {
const result = previewResult("CLOB", "preview", 5000);
result.value.large_value_context = { connectionId: "oceanbase-oracle-1", database: "MAXIMO", clientSessionId: "original-session" };
diff --git a/apps/desktop/src/composables/__tests__/useExportTracker.queue.spec.ts b/apps/desktop/src/composables/__tests__/useExportTracker.queue.spec.ts
new file mode 100644
index 0000000000..04c8731b4c
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useExportTracker.queue.spec.ts
@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/backend/api", () => ({ cancelTableExport: vi.fn() }));
+vi.mock("@/lib/export/exportPath", () => ({ autoRevealExportedPathIfConfigured: vi.fn() }));
+vi.mock("@/lib/schema/oracleRoutineDeploy", () => ({}));
+
+function completion() {
+ let finish!: (outcome: "settled" | "unknown") => void;
+ const promise = new Promise<"settled" | "unknown">((resolve) => {
+ finish = resolve;
+ });
+ return { run: vi.fn(() => promise), finish };
+}
+
+describe("export tracker queue", () => {
+ beforeEach(() => vi.resetModules());
+
+ it("shows waiting tasks without elapsed time and cancels them without backend calls", async () => {
+ const { useExportTracker } = await import("../useExportTracker");
+ const api = await import("@/lib/backend/api");
+ const tracker = useExportTracker();
+ const first = completion();
+ tracker.submitExportTask(tracker.addTask("first", "csv", "first.csv"), "queued", first.run);
+ const waiting = tracker.addTask("second", "csv", "second.csv");
+ const second = completion();
+ tracker.submitExportTask(waiting, "queued", second.run);
+
+ expect(waiting.status).toBe("Queued");
+ expect(waiting.startedAt).toBeUndefined();
+ expect(tracker.activeCount.value).toBe(2);
+ tracker.clearFinished();
+ expect(tracker.tasks.value).toHaveLength(2);
+ await tracker.cancelTask(waiting.exportId);
+ expect(waiting.status).toBe("Cancelled");
+ expect(api.cancelTableExport).not.toHaveBeenCalled();
+ first.finish("settled");
+ await Promise.resolve();
+ expect(second.run).not.toHaveBeenCalled();
+ });
+
+ it("retains unknown operations as active and does not clear or release them", async () => {
+ const { useExportTracker } = await import("../useExportTracker");
+ const tracker = useExportTracker();
+ const first = completion();
+ const running = tracker.addTask("first", "csv", "first.csv");
+ tracker.submitExportTask(running, "queued", first.run);
+ const second = completion();
+ tracker.submitExportTask(tracker.addTask("second", "csv", "second.csv"), "queued", second.run);
+ first.finish("unknown");
+ await Promise.resolve();
+
+ expect(running.status).toBe("Unknown");
+ expect(tracker.activeCount.value).toBe(2);
+ tracker.clearFinished();
+ expect(tracker.tasks.value).toHaveLength(2);
+ expect(second.run).not.toHaveBeenCalled();
+ });
+
+ it("releases a removed unknown task and starts the next one without retrying it", async () => {
+ const { useExportTracker } = await import("../useExportTracker");
+ const tracker = useExportTracker();
+ const first = completion();
+ const running = tracker.addTask("first", "csv", "first.csv");
+ tracker.submitExportTask(running, "queued", first.run);
+ const second = completion();
+ const waiting = tracker.addTask("second", "csv", "second.csv");
+ tracker.submitExportTask(waiting, "queued", second.run);
+ first.finish("unknown");
+ await Promise.resolve();
+
+ tracker.removeTask(running.exportId);
+
+ expect(tracker.tasks.value.map((task) => task.exportId)).toEqual([waiting.exportId]);
+ expect(tracker.activeCount.value).toBe(1);
+ expect(waiting.status).toBe("Running");
+ expect(second.run).toHaveBeenCalledOnce();
+ expect(first.run).toHaveBeenCalledOnce();
+
+ second.finish("settled");
+ await Promise.resolve();
+ });
+});
diff --git a/apps/desktop/src/composables/__tests__/useSidebarTreeExportRuntime.queue.spec.ts b/apps/desktop/src/composables/__tests__/useSidebarTreeExportRuntime.queue.spec.ts
new file mode 100644
index 0000000000..5a6c5402a2
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useSidebarTreeExportRuntime.queue.spec.ts
@@ -0,0 +1,341 @@
+import { shallowRef } from "vue";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { MongoExportProgress, MongoExportRequest, MongoExportSummary, TableExportProgress, TableExportRequest } from "@/lib/backend/api";
+import type { TreeNode, QueryResult } from "@/types/database";
+
+const mocks = vi.hoisted(() => ({ mode: vi.fn(), save: vi.fn(), export: vi.fn(), cancel: vi.fn(), ensure: vi.fn(), toast: vi.fn(), tableExport: vi.fn(), tableCancel: vi.fn(), query: vi.fn(), json: vi.fn(), buildSelect: vi.fn(), closeCursor: vi.fn(), closeClient: vi.fn() }));
+vi.mock("@/lib/backend/api", () => ({
+ exportMongodbQuery: mocks.export,
+ cancelMongodbExport: mocks.cancel,
+ startTableExport: mocks.tableExport,
+ cancelTableExport: mocks.tableCancel,
+ executeQuery: mocks.query,
+ exportQueryResultJson: mocks.json,
+ buildTableSelectSql: mocks.buildSelect,
+ closeQuerySession: mocks.closeCursor,
+ closeClientConnectionSession: mocks.closeClient,
+}));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn(async () => "C:/exports") }));
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => true }));
+vi.mock("@/lib/export/exportExecutionMode", () => ({ showExportExecutionModeDialog: mocks.mode }));
+vi.mock("@/lib/export/exportPath", () => ({ promptExportSavePath: mocks.save, autoRevealExportedPathIfConfigured: vi.fn() }));
+vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+vi.mock("@/i18n", () => ({ default: { install() {} } }));
+vi.mock("@/lib/schema/oracleRoutineDeploy", () => ({}));
+
+describe("sidebar Mongo manual export queue", () => {
+ const operations: Array<{ request: MongoExportRequest; progress: (value: MongoExportProgress) => void; resolve: (value: MongoExportSummary) => void; reject: (error: Error) => void }> = [];
+ const tables: Array<{ request: TableExportRequest; progress: (value: TableExportProgress) => void; resolve: (value: TableExportProgress) => void; reject: (error: Error) => void }> = [];
+ beforeEach(() => {
+ vi.resetModules();
+ vi.clearAllMocks();
+ operations.length = 0;
+ tables.length = 0;
+ mocks.mode.mockResolvedValue("queued");
+ mocks.save.mockResolvedValue("C:/exports/original.bson.gz");
+ mocks.ensure.mockResolvedValue(undefined);
+ mocks.cancel.mockResolvedValue(true);
+ mocks.tableCancel.mockResolvedValue(undefined);
+ mocks.json.mockReset().mockResolvedValue(undefined);
+ mocks.query.mockReset().mockResolvedValue({ columns: ["ID"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 });
+ mocks.buildSelect.mockImplementation(async ({ schema, tableName }) => `SELECT * FROM ${schema}.${tableName}`);
+ mocks.closeCursor.mockReset().mockResolvedValue(undefined);
+ mocks.closeClient.mockReset().mockResolvedValue(undefined);
+ mocks.tableExport.mockImplementation((request, progress) => new Promise((resolve, reject) => tables.push({ request, progress, resolve, reject })));
+ mocks.export.mockImplementation((request, progress) => new Promise((resolve, reject) => operations.push({ request, progress, resolve, reject })));
+ });
+
+ async function fixture() {
+ const { useSidebarTreeExportRuntime } = await import("../useSidebarTreeExportRuntime");
+ const { useExportTracker } = await import("../useExportTracker");
+ const activeNode = shallowRef({ id: "collection", type: "mongo-collection", connectionId: "mongo-1", database: "original", label: "docs" } as TreeNode);
+ const config = { id: "mongo-1", db_type: "mongodb", host: "original" };
+ const runtime = useSidebarTreeExportRuntime({ activeNode, connectionStore: { getConfig: () => config, ensureConnected: mocks.ensure } as never, settingsStore: { editorSettings: { preferredExportPath: "C:/exports" } } as never, acceptedSelectionIds: () => null });
+ return { runtime, tracker: useExportTracker(), activeNode };
+ }
+
+ async function tableFixture(multiple = false, dbType = "oracle") {
+ const { useSidebarTreeExportRuntime } = await import("../useSidebarTreeExportRuntime");
+ const { useExportTracker } = await import("../useExportTracker");
+ const first = { id: "first", type: "table", label: "A", connectionId: "oracle-1", database: "XE", schema: "HR" } as TreeNode;
+ const second = { ...first, id: "second", label: "B" };
+ const activeNode = shallowRef(first);
+ const settings = { editorSettings: { exportBatchSize: 123, exportRowLimitEnabled: false, csvQuoteMode: "minimal", csvNullMode: "empty", dataGridExtractorOptions: { sql: { primaryKeyMode: "include" } }, generateSqlIncludeDatabaseName: true } };
+ const runtime = useSidebarTreeExportRuntime({
+ activeNode,
+ connectionStore: { getConfig: () => ({ id: "oracle-1", db_type: dbType, host: "original" }), ensureConnected: mocks.ensure, connectionIdentifierQuote: () => '"', treeNodes: [first, second], selectedTreeNodeIds: multiple ? [first.id, second.id] : [] } as never,
+ settingsStore: settings as never,
+ acceptedSelectionIds: () => null,
+ });
+ return { runtime, tracker: useExportTracker(), activeNode, settings };
+ }
+
+ function finishTable(index: number, status: "Done" | "Cancelled" = "Done") {
+ const operation = tables[index]!;
+ const terminal: TableExportProgress = { exportId: operation.request.exportId, tableName: operation.request.tableName, rowsExported: 10, totalRows: 10, status };
+ operation.progress(terminal);
+ operation.resolve(terminal);
+ }
+
+ it("queues JSON reads and holds the lease through the actual writer", async () => {
+ const { runtime, tracker, activeNode } = await tableFixture();
+ let release!: () => void;
+ tracker.submitExportTask(
+ tracker.addTask("blocker", "csv", "first.csv"),
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ let written!: () => void;
+ mocks.json.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ written = resolve;
+ }),
+ );
+ await runtime.exportData("json");
+ expect(mocks.query).not.toHaveBeenCalled();
+ expect(mocks.ensure).not.toHaveBeenCalled();
+ activeNode.value = { ...activeNode.value, label: "OTHER", schema: "SECRET" };
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ release();
+ await vi.waitFor(() => expect(mocks.json).toHaveBeenCalledOnce());
+ expect(mocks.query).toHaveBeenCalledWith("oracle-1", "XE", "SELECT * FROM HR.A");
+ expect(mocks.json).toHaveBeenCalledWith("C:/exports/original.bson.gz", ["ID"], [[7]]);
+ expect(tracker.tasks.value[1]!.canCancel).toBe(false);
+ expect(next).not.toHaveBeenCalled();
+ written();
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ });
+
+ it.each(["completed", "transport"] as const)("waits for the actual JSON read after cancellation (%s)", async (outcome) => {
+ const { runtime, tracker } = await tableFixture();
+ let resolve!: (value: QueryResult) => void;
+ let reject!: (error: Error) => void;
+ mocks.query.mockImplementationOnce(
+ () =>
+ new Promise((yes, no) => {
+ resolve = yes;
+ reject = no;
+ }),
+ );
+ await runtime.exportData("json");
+ await vi.waitFor(() => expect(mocks.query).toHaveBeenCalledOnce());
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(next).not.toHaveBeenCalled();
+ expect(mocks.tableCancel).not.toHaveBeenCalled();
+ if (outcome === "transport") reject(new Error("read reply lost"));
+ else resolve({ columns: ["ID"], rows: [[7]], affected_rows: 0, execution_time_ms: 0 });
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe(outcome === "transport" ? "Unknown" : "Cancelled"));
+ expect(mocks.json).not.toHaveBeenCalled();
+ if (outcome === "completed") await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ else expect(next).not.toHaveBeenCalled();
+ });
+
+ it("keeps a swallowed cursor-close failure unknown and awaits the owned client close", async () => {
+ const { runtime, tracker } = await tableFixture(false, "cassandra");
+ mocks.query.mockResolvedValueOnce({ columns: ["ID"], rows: [[7]], affected_rows: 0, execution_time_ms: 0, has_more: false, session_id: "cursor-1" });
+ mocks.closeCursor.mockRejectedValueOnce(new Error("cursor close reply lost"));
+ let close!: () => void;
+ mocks.closeClient.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ close = resolve;
+ }),
+ );
+ await runtime.exportData("json");
+ await vi.waitFor(() => expect(mocks.closeClient).toHaveBeenCalledOnce());
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ expect(tracker.tasks.value[0]!.status).not.toBe("Done");
+ expect(next).not.toHaveBeenCalled();
+ close();
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe("Unknown"));
+ expect(mocks.json).not.toHaveBeenCalled();
+ expect(next).not.toHaveBeenCalled();
+ });
+
+ it("captures sidebar table requests while waiting without connecting", async () => {
+ const { runtime, tracker, activeNode, settings } = await tableFixture();
+ let release!: () => void;
+ tracker.submitExportTask(
+ tracker.addTask("blocker", "csv", "first.csv"),
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ await runtime.exportData("sql");
+ expect(mocks.ensure).not.toHaveBeenCalled();
+ expect(tables).toHaveLength(0);
+ activeNode.value = { ...activeNode.value, database: "OTHER", schema: "PRIVATE", label: "SECRET" };
+ settings.editorSettings.exportBatchSize = 999;
+ release();
+ await vi.waitFor(() => expect(tables).toHaveLength(1));
+ expect(tables[0]!.request).toMatchObject({ tableName: "A", database: "XE", schema: "HR", batchSize: 123 });
+ finishTable(0);
+ await vi.waitFor(() => expect(tracker.tasks.value[1]!.status).toBe("Done"));
+ });
+
+ it("cancels a waiting table without connecting or sending cancellation RPCs", async () => {
+ const { runtime, tracker } = await tableFixture();
+ let release!: () => void;
+ tracker.submitExportTask(
+ tracker.addTask("blocker", "csv", "first.csv"),
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ await runtime.exportData("csv");
+ await tracker.cancelTask(tracker.tasks.value[1]!.exportId);
+ release();
+ await Promise.resolve();
+ expect(tracker.tasks.value[1]!.status).toBe("Cancelled");
+ expect(mocks.ensure).not.toHaveBeenCalled();
+ expect(mocks.tableExport).not.toHaveBeenCalled();
+ expect(mocks.tableCancel).not.toHaveBeenCalled();
+ });
+
+ it("preserves successful terminal evidence after a late cancel and invoke rejection", async () => {
+ const { runtime, tracker } = await tableFixture();
+ await runtime.exportData("csv");
+ await vi.waitFor(() => expect(tables).toHaveLength(1));
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ const operation = tables[0]!;
+ operation.progress({ exportId: operation.request.exportId, tableName: "A", rowsExported: 10, totalRows: 10, status: "Done" });
+ expect(next).not.toHaveBeenCalled();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ operation.reject(new Error("invoke reply lost after terminal"));
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ expect(tracker.tasks.value[0]!.status).toBe("Done");
+ });
+
+ it("holds one batch lease until every table has completed", async () => {
+ const { runtime, tracker } = await tableFixture(true);
+ await runtime.exportData("csv");
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ await vi.waitFor(() => expect(tables).toHaveLength(1));
+ expect(tables[0]!.request.filePath).toBe("C:/exports/A.csv");
+ finishTable(0);
+ await vi.waitFor(() => expect(tables).toHaveLength(2));
+ expect(tables[1]!.request.filePath).toBe("C:/exports/B.csv");
+ expect(next).not.toHaveBeenCalled();
+ finishTable(1);
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ expect(tracker.tasks.value[0]!.status).toBe("Done");
+ });
+
+ it.each(["terminal", "transport"] as const)("does not release a cancelled table batch on cancel acknowledgement (%s)", async (outcome) => {
+ const { runtime, tracker } = await tableFixture(true);
+ await runtime.exportData("csv");
+ await vi.waitFor(() => expect(tables).toHaveLength(1));
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(mocks.tableCancel).toHaveBeenCalledWith(tables[0]!.request.exportId);
+ expect(next).not.toHaveBeenCalled();
+ if (outcome === "terminal") finishTable(0, "Cancelled");
+ else tables[0]!.reject(new Error("reply lost"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe(outcome === "terminal" ? "Cancelled" : "Unknown"));
+ expect(tables).toHaveLength(1);
+ if (outcome === "terminal") await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ else expect(next).not.toHaveBeenCalled();
+ });
+
+ it("captures the collection and waits for the actual summary rather than a terminal progress event", async () => {
+ const { runtime, tracker, activeNode } = await fixture();
+ let release!: () => void;
+ const blocker = tracker.addTask("blocker", "csv", "first.csv");
+ tracker.submitExportTask(
+ blocker,
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ await runtime.exportMongoCollection("bsonGzip");
+ expect(mocks.ensure).not.toHaveBeenCalled();
+ expect(operations).toHaveLength(0);
+ activeNode.value = { ...activeNode.value, connectionId: "other", database: "private", label: "other" };
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ release();
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ const operation = operations[0]!;
+ expect(operation.request).toMatchObject({ connectionId: "mongo-1", database: "original", collection: "docs", format: "bson", gzip: true, filePath: "C:/exports/original.bson.gz" });
+ operation.progress({ exportId: operation.request.exportId, status: "done", documentsRead: 2, bytesWritten: 20, elapsedMs: 1 });
+ expect(tracker.tasks.value[1]!.status).toBe("Writing");
+ expect(next).not.toHaveBeenCalled();
+ operation.resolve({ exportId: operation.request.exportId, documentsExported: 2, filePath: operation.request.filePath, elapsedMs: 1 });
+ await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ expect(tracker.tasks.value[1]!.status).toBe("Done");
+ });
+
+ it("cancels a waiting collection without connecting or sending an export", async () => {
+ const { runtime, tracker } = await fixture();
+ let release!: () => void;
+ tracker.submitExportTask(
+ tracker.addTask("blocker", "csv", "first.csv"),
+ "immediate",
+ () =>
+ new Promise((resolve) => {
+ release = () => resolve("settled");
+ }),
+ );
+ await runtime.exportMongoCollection("csv");
+ await tracker.cancelTask(tracker.tasks.value[1]!.exportId);
+ release();
+ await Promise.resolve();
+ expect(tracker.tasks.value[1]!.status).toBe("Cancelled");
+ expect(mocks.ensure).not.toHaveBeenCalled();
+ expect(mocks.export).not.toHaveBeenCalled();
+ expect(mocks.cancel).not.toHaveBeenCalled();
+ });
+
+ it("keeps a running cancellation acknowledgement and transport rejection unknown", async () => {
+ const { runtime, tracker } = await fixture();
+ await runtime.exportMongoCollection("ndjson");
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelling");
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(mocks.cancel).toHaveBeenCalledTimes(1);
+ expect(mocks.cancel).toHaveBeenCalledWith(operations[0]!.request.exportId);
+ expect(next).not.toHaveBeenCalled();
+ operations[0]!.reject(new Error("transport lost"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe("Unknown"));
+ expect(next).not.toHaveBeenCalled();
+ expect(tracker.tasks.value[0]!.finishedAt).toBeUndefined();
+ });
+
+ it.each(["failed", "cancelled", "unknown"] as const)("uses reported Mongo completion rather than terminal progress (%s)", async (status) => {
+ const { runtime, tracker } = await fixture();
+ const { SnapshotCompletionError } = await import("@/lib/export/snapshotCompletion");
+ await runtime.exportMongoCollection("csv");
+ await vi.waitFor(() => expect(operations).toHaveLength(1));
+ expect(mocks.export.mock.calls[0]![2]).toBe(true);
+ const next = vi.fn().mockResolvedValue("settled");
+ tracker.submitExportTask(tracker.addTask("next", "csv", "next.csv"), "queued", next);
+ const operation = operations[0]!;
+ operation.progress({ exportId: operation.request.exportId, status: "cancelled", documentsRead: 1, bytesWritten: 10, elapsedMs: 1 });
+ expect(next).not.toHaveBeenCalled();
+ operation.reject(new SnapshotCompletionError(status, "completion evidence"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe(status === "unknown" ? "Unknown" : status === "cancelled" ? "Cancelled" : "Error"));
+ if (status === "unknown") expect(next).not.toHaveBeenCalled();
+ else await vi.waitFor(() => expect(next).toHaveBeenCalledOnce());
+ });
+});
diff --git a/apps/desktop/src/composables/__tests__/useSidebarTreeExportRuntime.spec.ts b/apps/desktop/src/composables/__tests__/useSidebarTreeExportRuntime.spec.ts
index 1699494d22..5812c3ffc6 100644
--- a/apps/desktop/src/composables/__tests__/useSidebarTreeExportRuntime.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useSidebarTreeExportRuntime.spec.ts
@@ -534,6 +534,7 @@ describe("useSidebarTreeExportRuntime", () => {
activeNode.value = { id: "table-2", type: "table", label: "orders", connectionId: "conn-2", database: "db-b", schema: "sales", children: [] } as TreeNode;
settingsStore.editorSettings.exportBatchSize = 16;
settingsStore.editorSettings.exportRowLimit = 10;
+ settingsStore.editorSettings.dataGridExtractorOptions = { ...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS, sql: { ...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS.sql, primaryKeyMode: "exclude-all" } };
metadata.resolve([column("name")]);
await exportPromise;
@@ -549,6 +550,7 @@ describe("useSidebarTreeExportRuntime", () => {
columns: ["name"],
batchSize: 128,
rowLimit: 500,
+ primaryKeyMode: "include",
}),
expect.any(Function),
);
diff --git a/apps/desktop/src/composables/useDataGridExport.ts b/apps/desktop/src/composables/useDataGridExport.ts
index d67872f362..3eccc18167 100644
--- a/apps/desktop/src/composables/useDataGridExport.ts
+++ b/apps/desktop/src/composables/useDataGridExport.ts
@@ -42,6 +42,12 @@ import XlsxHeaderDialog from "@/components/export/XlsxHeaderDialog.vue";
import i18n from "@/i18n";
import { buildXlsxHeaderOverrides, hasXlsxHeaderComments, xlsxHeaderUsesCommentRows, type XlsxExportOptions, type XlsxHeaderMode } from "@/lib/export/xlsxHeader";
import { isPartiallyLoadedCopy, partialLoadCopyHintKey, type PartialLoadCopyInfo } from "@/lib/dataGrid/copyPartialLoadHint";
+import { showExportExecutionModeDialog } from "@/lib/export/exportExecutionMode";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
+import type { CapturedLegacyLargeValueExport } from "@/lib/dataGrid/legacyLargeValueExport";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
/**
* Format metadata for backend table exports. Each entry maps a format key
@@ -79,6 +85,13 @@ export function normalizeExportTarget(target?: ExportTargetParam, columnIndexesP
};
}
+export interface DataGridExportSheet {
+ sheetName: string;
+ result: QueryResult;
+ sql?: string;
+ captureSourceValues?: () => CapturedLegacyLargeValueExport;
+}
+
interface RowItem {
id: number;
sourceIndex?: number;
@@ -116,6 +129,7 @@ export interface UseDataGridExportOptions {
mongoUpdateTarget?: ComputedRef<MongoCopyUpdateTarget | undefined>;
databaseType: ComputedRef<DatabaseType | undefined>;
displayValue?: (value: CellValue, columnIndex: number) => string;
+ captureColumnFormatterDisplay?: () => (value: CellValue, columnIndex: number) => string;
editValue?: (value: CellValue, columnIndex: number) => string;
hasColumnFormatter?: (columnIndex: number) => boolean;
applyColumnFormattersOnExport?: ComputedRef<boolean>;
@@ -147,7 +161,10 @@ export interface UseDataGridExportOptions {
selectedRowIds: Ref<Set<number>> | ComputedRef<Set<number>>;
hasRowSelection: ComputedRef<boolean>;
resolveSourceValues?: (rowIds: number[], sourceColumnIndexes: number[]) => Promise<Map<number, Map<number, CellValue>>>;
- fullExportResult?: (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void) => Promise<QueryResult | undefined>;
+ captureSourceValues?: (cells: Array<{ rowId: number; sourceIndex: number; columnIndex: number }>) => (signal: AbortSignal) => Promise<Map<number, Map<number, CellValue>>>;
+ fullExportResult?: (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void, control?: { signal: AbortSignal }) => Promise<QueryResult | undefined>;
+ captureFullExportResult?: () => UseDataGridExportOptions["fullExportResult"];
+ captureQueryResultExportRequest?: (queued: boolean) => UseDataGridExportOptions["queryResultExportRequest"];
queryResultExportRequest?: (options: {
exportId: string;
filePath: string;
@@ -179,7 +196,7 @@ export interface UseDataGridExportOptions {
*/
completeLocalResult?: ComputedRef<QueryResult | undefined>;
snapshotResult?: ComputedRef<QueryResult>;
- allExportResults?: ComputedRef<Array<{ sheetName: string; result: QueryResult; sql?: string }> | undefined>;
+ allExportResults?: ComputedRef<DataGridExportSheet[] | undefined>;
currentResultLabel?: ComputedRef<string | undefined>;
exportFileBaseName?: ComputedRef<string | undefined>;
exportProgressDialog?: Ref<boolean>;
@@ -207,17 +224,18 @@ interface CopyInsertData {
}
export function useDataGridExport(options: UseDataGridExportOptions) {
- let activeSnapshotCancel: (() => Promise<void>) | undefined;
+ const activeSnapshotCancels = new Set<() => Promise<void>>();
let scopeDisposed = false;
if (getCurrentScope())
onScopeDispose(() => {
scopeDisposed = true;
- void activeSnapshotCancel?.().catch(() => undefined);
+ for (const cancel of activeSnapshotCancels) void cancel().catch(() => undefined);
});
const { t } = useI18n();
const { toast } = useToast();
const tracker = useExportTracker();
const exportGuard: ActionActivationGuard = {};
+ let currentExportViewId: string | undefined;
const {
columns,
@@ -335,7 +353,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
controller.abort(new Error("LOB export cancelled locally"));
await api.cancelQuery(executionId);
};
- activeSnapshotCancel = cancel;
+ activeSnapshotCancels.add(cancel);
const previousCancel = exportCancelHandler?.value;
if (exportCancelHandler) exportCancelHandler.value = cancel;
const stop = watch(
@@ -349,7 +367,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return await materializeSnapshotResultRows(result, isCurrent, controller.signal, executionId);
} finally {
stop();
- if (activeSnapshotCancel === cancel) activeSnapshotCancel = undefined;
+ activeSnapshotCancels.delete(cancel);
if (exportCancelHandler?.value === cancel) exportCancelHandler.value = previousCancel ?? null;
}
}
@@ -390,26 +408,33 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const allXlsxColumnComments = computed(() => allColumnCommentsOption?.value ?? tableCommentsForColumns(allColumns.value));
function commentsForExportColumns(targetColumns: readonly string[], preferAllColumns = true): Array<string | undefined> {
- const sourceColumns = preferAllColumns ? allColumns.value : columns.value;
- const sourceComments = preferAllColumns ? allXlsxColumnComments.value : visibleXlsxColumnComments.value;
- if (targetColumns.length === sourceColumns.length && targetColumns.every((column, index) => column === sourceColumns[index])) {
- return [...sourceComments];
- }
+ return captureExportColumnComments(preferAllColumns)(targetColumns);
+ }
- const commentsByName = new Map<string, string>();
- sourceColumns.forEach((column, index) => {
- const comment = sourceComments[index];
- if (comment) commentsByName.set(column.toLocaleLowerCase(), comment);
- });
- for (const column of tableMeta.value?.columns ?? []) {
- if (column.comment && !commentsByName.has(column.name.toLocaleLowerCase())) {
- commentsByName.set(column.name.toLocaleLowerCase(), column.comment);
+ function captureExportColumnComments(preferAllColumns = true) {
+ const sourceColumns = [...(preferAllColumns ? allColumns.value : columns.value)];
+ const sourceComments = [...(preferAllColumns ? allXlsxColumnComments.value : visibleXlsxColumnComments.value)];
+ const metadataColumns = tableMeta.value?.columns?.map((column) => ({ name: column.name, comment: column.comment })) ?? [];
+ return (targetColumns: readonly string[]): Array<string | undefined> => {
+ if (targetColumns.length === sourceColumns.length && targetColumns.every((column, index) => column === sourceColumns[index])) {
+ return [...sourceComments];
}
- }
- return targetColumns.map((column) => commentsByName.get(column.toLocaleLowerCase()));
+
+ const commentsByName = new Map<string, string>();
+ sourceColumns.forEach((column, index) => {
+ const comment = sourceComments[index];
+ if (comment) commentsByName.set(column.toLocaleLowerCase(), comment);
+ });
+ for (const column of metadataColumns) {
+ if (column.comment && !commentsByName.has(column.name.toLocaleLowerCase())) {
+ commentsByName.set(column.name.toLocaleLowerCase(), column.comment);
+ }
+ }
+ return targetColumns.map((column) => commentsByName.get(column.toLocaleLowerCase()));
+ };
}
- function showXlsxHeaderDialog(): Promise<XlsxExportOptions | null> {
+ function showXlsxHeaderDialog(showExecutionMode = false): Promise<XlsxExportOptions | null> {
if (typeof document === "undefined") return Promise.resolve({ headerMode: "name", autoFilter: false });
return new Promise((resolve) => {
@@ -417,6 +442,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
document.body.appendChild(container);
const app = createApp(XlsxHeaderDialog, {
open: true,
+ showExecutionMode,
showHeaderOptions: hasXlsxHeaderComments(allXlsxColumnComments.value) || hasXlsxHeaderComments(visibleXlsxColumnComments.value),
onConfirm: (exportOptions: XlsxExportOptions) => {
resolve(exportOptions);
@@ -477,8 +503,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
};
}
- function mongoDocumentRowsForJson(columnsToExport: string[], rows: CellValue[][], documents: unknown[] | undefined): CellValue[][] {
- if (databaseType.value !== "mongodb" || !documents || documents.length !== rows.length) return rows;
+ function mongoDocumentRowsForJson(columnsToExport: string[], rows: CellValue[][], documents: unknown[] | undefined, isMongo = databaseType.value === "mongodb"): CellValue[][] {
+ if (!isMongo || !documents || documents.length !== rows.length) return rows;
return rows.map((row, rowIndex) => {
const document = documents[rowIndex];
if (!document || typeof document !== "object" || Array.isArray(document)) return row;
@@ -534,6 +560,42 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return rows.map((row) => row.map((value, columnIndex) => externalCellValue(value, columnIndex, undefined, applyFormatters)));
}
+ function captureFullResultProjection(columnIndexes: number[] | undefined, formatDateTime: boolean, headerMode: XlsxHeaderMode, preserveMongoExtendedJson: boolean) {
+ const isMongo = databaseType.value === "mongodb";
+ const isOracle = databaseType.value === "oracle" || databaseType.value === "oceanbase-oracle";
+ const indexes = (columnIndexes ?? columns.value.map((_, index) => index)).filter((index) => index >= 0 && index < columns.value.length);
+ const targetColumns = indexes.map((index) => columns.value[index]!);
+ const sourceIndexes = visibleColumnIndexesOption?.value ? indexes.map((index) => visibleColumnIndexesOption.value?.[index] ?? index) : undefined;
+ const comments = captureExportColumnComments();
+ const settings = { ...useSettingsStore().editorSettings };
+ const formattedIndexes = new Set(allColumns.value.map((_, index) => index).filter((index) => shouldApplyColumnFormatter(index)));
+ const display = options.captureColumnFormatterDisplay?.() ?? options.displayValue;
+ return (result: QueryResult): Awaited<ReturnType<typeof resultToExport>> => {
+ const projected = isMongo || columnIndexes !== undefined ? projectResultColumns(result, targetColumns, sourceIndexes) : undefined;
+ const exportedColumns = projected?.columns ?? result.columns;
+ const exportedTypes = projected?.columnTypes ?? result.column_types ?? [];
+ const rawRows = projected?.rows ?? result.rows;
+ const rows =
+ preserveMongoExtendedJson && isMongo
+ ? mongoDocumentRowsForJson(exportedColumns, rawRows, result.mongo_copy_documents, true)
+ : rawRows.map((row) =>
+ row.map((value, index) => {
+ const sourceIndex = sourceIndexes?.[index] ?? index;
+ return formatDateTime && display && value !== null && (formattedIndexes.has(sourceIndex) || (isOracle && isTemporalColumnType(exportedTypes[index]))) ? display(value, sourceIndex) : value;
+ }),
+ );
+ const effectiveTypes = exportedTypes.map((type, index) => (formattedIndexes.has(sourceIndexes?.[index] ?? index) ? undefined : type));
+ return {
+ columns: exportedColumns,
+ columnTypes: exportedTypes,
+ columnComments: buildXlsxHeaderOverrides(exportedColumns, comments(exportedColumns), headerMode),
+ rows: formatDateTime && !preserveMongoExtendedJson && settings.globalDateTimeExportFormat ? formatTemporalRowsForExport(rows, effectiveTypes, settings.globalDateTimeExportFormat) : rows,
+ spatialColumns: projected?.spatialColumns ?? result.spatial_columns,
+ spatialValues: projected?.spatialValues ?? result.spatial_values,
+ };
+ };
+ }
+
async function resultToExport(
target?: ExportTargetParam,
onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void,
@@ -542,6 +604,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
headerMode: XlsxHeaderMode = "name",
preserveMongoExtendedJson = false,
columnIndexesParam?: number[],
+ sourceValuesAlreadyComplete = false,
): Promise<{
columns: string[];
columnTypes: string[];
@@ -561,26 +624,14 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const projectionSourceIndexes = visibleSourceIndexes ? validColumnIndexes.map((targetIdx) => visibleSourceIndexes[targetIdx] ?? targetIdx) : undefined;
if (useFullExport && rowIds === undefined && fullExportResult && !hasCompleteLocalResult?.value) {
+ const project = captureFullResultProjection(columnIndexes, formatDateTime, headerMode, preserveMongoExtendedJson);
const result = await fullExportResult(onProgress);
if (result) {
- const projected = databaseType.value === "mongodb" || hasColumnSubset ? projectResultColumns(result, targetColumns, projectionSourceIndexes) : undefined;
- const exportedColumns = projected?.columns ?? result.columns;
- const exportedColumnTypes = projected?.columnTypes ?? result.column_types ?? [];
- const exportedRows = projected?.rows ?? result.rows;
- const exportedSpatialColumns = projected?.spatialColumns ?? result.spatial_columns;
- const exportedSpatialValues = projected?.spatialValues ?? result.spatial_values;
- const columnComments = buildXlsxHeaderOverrides(exportedColumns, commentsForExportColumns(exportedColumns), headerMode);
// fullExportResult returns source rows, not the collection grid's
// marker-encoded rows. Applying the Mongo externalCellValue decode here would
// mistake a real BSON string in the reserved namespace for a grid marker and
// corrupt the exported value — only the formatter-gated displayValue may run.
- const resolvedRows = preserveMongoExtendedJson ? mongoDocumentRowsForJson(exportedColumns, exportedRows, result.mongo_copy_documents) : exportedRows.map((row) => row.map((value, colIdx) => externalCellValue(value, colIdx, projectionSourceIndexes?.[colIdx] ?? colIdx, formatDateTime, true)));
- return {
- ...applyGlobalDateTimeExportFormat({ columns: exportedColumns, columnTypes: exportedColumnTypes, rows: resolvedRows }, formatDateTime && !preserveMongoExtendedJson, projectionSourceIndexes),
- columnComments,
- spatialColumns: exportedSpatialColumns,
- spatialValues: exportedSpatialValues,
- };
+ return project(result);
}
}
// The full result is already in memory — export all rows with the source
@@ -620,7 +671,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const commentHeader = buildXlsxHeaderOverrides(targetColumns, targetComments, headerMode);
const visibleIndexes = visibleColumnIndexesOption?.value ?? columns.value.map((_, index) => index);
const targetSourceIndexes = validColumnIndexes.map((targetIdx) => visibleIndexes[targetIdx] ?? targetIdx);
- const exportItems = await resolveVisibleRowValues(rowsToExport(rowIds), targetSourceIndexes);
+ const exportItems = sourceValuesAlreadyComplete ? rowsToExport(rowIds) : await resolveVisibleRowValues(rowsToExport(rowIds), targetSourceIndexes);
const targetIndexBySource = new Map<number, number>();
targetSourceIndexes.forEach((sourceIdx, targetIdx) => {
targetIndexBySource.set(sourceIdx, targetIdx);
@@ -672,8 +723,34 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return resultPageSql?.value || currentExportSql();
}
+ function captureExportConfirmationSource() {
+ const sourceConnection = connectionId.value;
+ const sourceDatabase = database.value;
+ const sourceSql = currentExportSql();
+ const sourceResult = options.snapshotResult?.value;
+ const sourceCompleteResult = completeLocalResult?.value;
+ const table = tableMeta.value?.tableName;
+ const schema = tableMeta.value?.schema;
+ const catalog = tableMeta.value?.catalog;
+ return () =>
+ !scopeDisposed &&
+ connectionId.value === sourceConnection &&
+ database.value === sourceDatabase &&
+ currentExportSql() === sourceSql &&
+ options.snapshotResult?.value === sourceResult &&
+ completeLocalResult?.value === sourceCompleteResult &&
+ tableMeta.value?.tableName === table &&
+ tableMeta.value?.schema === schema &&
+ tableMeta.value?.catalog === catalog;
+ }
+
async function writeXlsxResult(outputPath: string, result: { columns: string[]; columnTypes: string[]; columnComments?: (string | null)[]; rows: CellValue[][] }, includeSqlSheet: boolean, autoFilter: boolean, sqlOverride?: string, headerCommentRows = false) {
- if (options.snapshotResult?.value.large_value_refs?.length || options.snapshotResult?.value.large_value_cells?.some((cell) => cell.value_ref)) assertSnapshotXlsxCellLengths(result.rows);
+ await captureXlsxWriter(includeSqlSheet, autoFilter, sqlOverride, headerCommentRows)(outputPath, result);
+ }
+
+ function captureXlsxWriter(includeSqlSheet: boolean, autoFilter: boolean, sqlOverride?: string, headerCommentRows = false) {
+ const checkLobLengths = !!(options.snapshotResult?.value.large_value_refs?.length || options.snapshotResult?.value.large_value_cells?.some((cell) => cell.value_ref));
+ const sheetName = currentXlsxSheetName();
const effectiveSql = sqlOverride ?? currentExportSql();
const sqlWorksheet = includeSqlSheet ? buildXlsxSqlWorksheet([{ sql: effectiveSql || "" }]) : undefined;
const rightAlign = useSettingsStore().editorSettings.numericColumnRightAlign;
@@ -681,28 +758,31 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
// workbook still needs the pattern itself so its numFmt matches; without it
// a `SSS` pattern silently displays as `yyyy-mm-dd hh:mm:ss`.
const dateTimeFormat = useSettingsStore().editorSettings.globalDateTimeExportFormat || undefined;
- if (!sqlWorksheet) {
- await api.exportQueryResultXlsx(outputPath, currentXlsxSheetName(), result.columns, result.columnTypes, result.columnComments, result.rows, rightAlign, autoFilter, dateTimeFormat, headerCommentRows);
- return;
- }
- await api.exportQueryResultsXlsx(
- outputPath,
- [
- {
- sheetName: currentXlsxSheetName(),
- columns: result.columns,
- columnTypes: result.columnTypes,
- columnComments: result.columnComments,
- rows: result.rows,
- numericColumnRightAlign: rightAlign,
- autoFilter,
- headerCommentRows,
- },
- { ...sqlWorksheet, autoFilter: false },
- ],
- autoFilter,
- dateTimeFormat,
- );
+ return async (outputPath: string, result: { columns: string[]; columnTypes: string[]; columnComments?: (string | null)[]; rows: CellValue[][] }) => {
+ if (checkLobLengths) assertSnapshotXlsxCellLengths(result.rows);
+ if (!sqlWorksheet) {
+ await api.exportQueryResultXlsx(outputPath, sheetName, result.columns, result.columnTypes, result.columnComments, result.rows, rightAlign, autoFilter, dateTimeFormat, headerCommentRows);
+ return;
+ }
+ await api.exportQueryResultsXlsx(
+ outputPath,
+ [
+ {
+ sheetName,
+ columns: result.columns,
+ columnTypes: result.columnTypes,
+ columnComments: result.columnComments,
+ rows: result.rows,
+ numericColumnRightAlign: rightAlign,
+ autoFilter,
+ headerCommentRows,
+ },
+ { ...sqlWorksheet, autoFilter: false },
+ ],
+ autoFilter,
+ dateTimeFormat,
+ );
+ };
}
function targetedRows(): RowItem[] {
@@ -1026,6 +1106,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
async function runExclusiveExport(action: () => Promise<void>) {
const finish = tryStartExclusiveActivation(exportGuard);
if (!finish) return;
+ currentExportViewId = undefined;
try {
await action();
} finally {
@@ -1055,11 +1136,20 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return exported;
}
- async function exportLocalSnapshot(format: "csv" | "json", rowIds: number[] | undefined, columnIndexes: number[] | undefined, full: boolean): Promise<boolean> {
+ async function exportLocalSnapshot(
+ format: "csv" | "json" | "xlsx" | "markdown" | "html" | "txt" | "sql",
+ rowIds: number[] | undefined,
+ columnIndexes: number[] | undefined,
+ full: boolean,
+ exportOptions: { xlsx?: XlsxExportOptions; includeSqlSheet?: boolean; sql?: SqlExportOptions; openAfterExport?: boolean } = {},
+ ): Promise<boolean> {
const original = options.snapshotResult?.value;
const originalConnectionId = connectionId.value;
const originalDatabase = database.value;
- const isCurrent = () => options.snapshotResult?.value === original && connectionId.value === originalConnectionId && database.value === originalDatabase;
+ const native = isTauriRuntime();
+ if (!native && format !== "csv" && format !== "json") return false;
+ const streamedSnapshot = format === "csv" || format === "json";
+ const applyFormatting = format !== "sql";
if (!original || (full && rowIds === undefined && !hasCompleteLocalResult?.value)) return false;
const exportAll = full && rowIds === undefined && hasCompleteLocalResult?.value;
const visibleIndexes = visibleColumnIndexesOption?.value ?? columns.value.map((_, index) => index);
@@ -1067,98 +1157,325 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const hiddenIndexes = new Set(original.hidden_column_indexes ?? []);
const sourceIndexes = exportAll && !indexes ? original.columns.map((_, index) => index).filter((index) => !hiddenIndexes.has(index)) : (indexes ?? columns.value.map((_, index) => index)).map((index) => visibleIndexes[index] ?? index);
const names = sourceIndexes.map((index) => original.columns[index]!);
- const editorSettings = useSettingsStore().editorSettings;
+ const editorSettings = { ...useSettingsStore().editorSettings };
const originalRows = editorSettings.exportRowLimitEnabled ? original.rows.slice(0, editorSettings.exportRowLimit) : original.rows;
const items = exportAll
- ? originalRows.map((row, sourceIndex) => ({ sourceIndex, data: sourceIndexes.map((index) => row[index]) }))
+ ? originalRows.map((row, sourceIndex) => ({ id: sourceIndex, sourceIndex, isNew: false, isDirtyCol: [] as boolean[], data: sourceIndexes.map((index) => row[index]) }))
: rowsToExport(rowIds).map((item) => ({
+ id: item.id,
sourceIndex: item.sourceIndex,
isNew: item.isNew,
data: (indexes ?? columns.value.map((_, index) => index)).map((index) => item.data[index]),
isDirtyCol: (indexes ?? columns.value.map((_, index) => index)).map((index) => item.isDirtyCol[index] ?? false),
}));
- const selected = snapshotExportSelection(original, names, sourceIndexes, items);
- if (!selected) return false;
+ const legacyMetadata = new Map(original.large_value_cells?.filter((cell) => !cell.value_ref).map((cell) => [`${cell.row_index}:${cell.column_index}`, cell]));
+ const legacyCells = items.flatMap((item, rowIndex) =>
+ sourceIndexes.flatMap((columnIndex, targetColumnIndex) => {
+ if (item.isNew || item.sourceIndex === undefined || item.isDirtyCol?.[targetColumnIndex]) return [];
+ const cell = legacyMetadata.get(`${item.sourceIndex}:${columnIndex}`);
+ return cell ? [{ rowId: item.id, sourceIndex: item.sourceIndex, columnIndex, rowIndex, targetColumnIndex }] : [];
+ }),
+ );
+ const resolveLegacy = native && legacyCells.length ? options.captureSourceValues?.(legacyCells) : undefined;
+ if (legacyCells.length && !resolveLegacy) return false;
+ const locatorSelection = snapshotExportSelection(original, names, sourceIndexes, items);
+ if (!locatorSelection && !resolveLegacy) return false;
+ const selected = locatorSelection ?? { columns: names, rows: items.map((item) => item.data), cells: [], context: { connectionId: originalConnectionId!, database: originalDatabase!, valueRef: "" } };
+ const hasLocators = !!locatorSelection;
const types = sourceIndexes.map((index) => original.column_types?.[index] ?? "");
- let outputPath = exportFileName(full ? "export" : "export-page", format, { page: !full });
- if (isTauriRuntime()) {
- const path = await promptExportSavePath({ defaultFileName: outputPath, filters: [{ name: FORMAT_META[format]!.label, extensions: [format] }], preferredPath: useSettingsStore().editorSettings.preferredExportPath });
+ const title = currentExportTitle();
+ const formattedCells = selected.cells.filter((cell) => applyFormatting && shouldApplyColumnFormatter(sourceIndexes[cell.columnIndex]!));
+ const materializedCells = streamedSnapshot ? formattedCells : selected.cells;
+ const formattedLegacyCells = legacyCells.filter((cell) => applyFormatting && shouldApplyColumnFormatter(cell.columnIndex));
+ const formatterDisplay = formattedCells.length || formattedLegacyCells.length ? (options.captureColumnFormatterDisplay?.() ?? options.displayValue) : undefined;
+ selected.rows = selected.rows.map((row) => row.map((value, columnIndex) => externalCellValue(value as CellValue, exportAll ? sourceIndexes[columnIndex]! : (indexes?.[columnIndex] ?? columnIndex), sourceIndexes[columnIndex], applyFormatting, !!exportAll)));
+ selected.rows = applyGlobalDateTimeExportFormat({ columns: names, columnTypes: types, rows: selected.rows as CellValue[][] }, applyFormatting, sourceIndexes).rows;
+ const materializationResult = {
+ ...original,
+ rows: selected.rows as CellValue[][],
+ large_value_context: original.large_value_context ? { ...original.large_value_context } : undefined,
+ large_value_cells: materializedCells.map((cell) => ({ ...original.large_value_cells!.find((source) => source.value_ref === cell.valueRef)!, row_index: cell.rowIndex, column_index: cell.columnIndex })),
+ };
+ const headerMode = exportOptions.xlsx?.headerMode ?? "name";
+ const xlsxComments = buildXlsxHeaderOverrides(names, commentsForExportColumns(names), headerMode);
+ const writeWorkbook = format === "xlsx" ? captureXlsxWriter(exportOptions.includeSqlSheet === true, exportOptions.xlsx?.autoFilter ?? false, full ? undefined : currentPageExportSql(), xlsxHeaderUsesCommentRows(headerMode)) : undefined;
+ const targetIndexBySource = new Map(sourceIndexes.map((sourceIndex, index) => [sourceIndex, index]));
+ const projectedSpatialColumns = original.spatial_columns?.flatMap((column) => {
+ const index = targetIndexBySource.get(column.column_index);
+ return index === undefined ? [] : [{ ...column, column_index: index }];
+ });
+ const projectedSpatialValues = original.spatial_values?.length ? items.map((item) => sourceIndexes.map((index) => original.spatial_values?.[item.sourceIndex ?? -1]?.[index] ?? null)) : undefined;
+ const projectSql = format === "sql" ? captureSqlInsertExportData({ columns: names, columnTypes: types, rows: selected.rows as CellValue[][], spatialColumns: projectedSpatialColumns, spatialValues: projectedSpatialValues }, exportOptions.sql?.selectedColumns) : undefined;
+ const insertTarget = format === "sql" ? sqlInsertTargetMeta() : undefined;
+ const sqlMetadata = projectSql?.([]);
+ const insertOptions = sqlMetadata
+ ? { databaseType: databaseType.value, identifierQuote: options.identifierQuote?.value, schema: sqlInsertTargetSchema(insertTarget), tableName: sqlInsertTargetName(insertTarget), insertMode: exportOptions.sql?.insertMode, excludeColumns: sqlExportExcludedColumns(sqlMetadata.columns) }
+ : undefined;
+ const connections = native && getActivePinia() ? useConnectionStore() : undefined;
+ const resourceConnectionId = selected.context.connectionId;
+ const revision = connections?.connectionStateRevision(resourceConnectionId);
+ const originalConfig = connections?.getConfig(resourceConnectionId);
+ const fingerprint = originalConfig ? connectionConfigFingerprint(originalConfig) : undefined;
+ const isCurrent = () => {
+ if (!hasLocators) return true;
+ if (scopeDisposed || options.snapshotResult?.value !== original || connectionId.value !== originalConnectionId || database.value !== originalDatabase) return false;
+ if (!connections) return true;
+ const current = connections.getConfig(resourceConnectionId);
+ return connections.isCurrentConnectionStateRevision(resourceConnectionId, revision!) && !!current && connectionConfigFingerprint(current) === fingerprint;
+ };
+ const fileFormat = FORMAT_META[format]!;
+ let outputPath = full && (format === "txt" || format === "sql") ? exportFileName(tableMeta.value?.tableName || "export", fileFormat.ext, { preferFallback: true }) : exportFileName(full ? "export" : "export-page", fileFormat.ext, { page: !full });
+ const mode = exportOptions.openAfterExport ? "immediate" : (exportOptions.xlsx?.executionMode ?? exportOptions.sql?.executionMode ?? (await showExportExecutionModeDialog()));
+ if (mode === null) return true;
+ if (native) {
+ const path = exportOptions.openAfterExport ? await api.createQueryResultTempFile(fileFormat.ext) : await promptExportSavePath({ defaultFileName: outputPath, filters: [{ name: fileFormat.label, extensions: [fileFormat.ext] }], preferredPath: editorSettings.preferredExportPath });
if (!path) return true;
outputPath = path;
}
- if (!isCurrent()) throw new Error("LOB result context changed");
+ if (options.snapshotResult?.value !== original || connectionId.value !== originalConnectionId || database.value !== originalDatabase || !isCurrent()) throw new Error("LOB result context changed");
const executionId = uuid();
const controller = new AbortController();
- const cancel = async () => {
- controller.abort(new Error("LOB export cancelled locally"));
- await api.cancelQuery(executionId);
+ let userCancelled = false;
+ const cancel = async (user: boolean) => {
+ if (!controller.signal.aborted) userCancelled = user;
+ controller.abort(new Error(user ? "LOB export cancelled locally" : "LOB result context changed"));
+ if (hasLocators) await api.cancelQuery(executionId);
};
- activeSnapshotCancel = cancel;
- const title = currentExportTitle();
- tracker.addTask(title, format, outputPath, executionId);
- tracker.registerTaskCancelHandler(executionId, cancel);
- if (exportProgressState)
- exportProgressState.value = {
- title: t("exportProgress.title"),
- tableName: title,
- format,
- rowsExported: 0,
- totalRows: selected.rows.length,
- status: "Running",
- errorMessage: null,
- filePath: outputPath,
- startedAt: Date.now(),
- finishedAt: undefined,
- };
- if (exportProgressDialog) exportProgressDialog.value = true;
- if (exportCanMinimize) exportCanMinimize.value = true;
- const previousCancel = exportCancelHandler?.value;
- if (exportCancelHandler) exportCancelHandler.value = cancel;
- const stop = watch(
- () => [options.snapshotResult?.value, connectionId.value, database.value],
- () => {
- if (!isCurrent()) void cancel().catch(() => undefined);
+ const cancelSource = () => cancel(false);
+ await submitBackendExport({
+ exportId: executionId,
+ tableName: title,
+ format,
+ outputPath,
+ mode,
+ openAfterExport: exportOptions.openAfterExport === true,
+ cancelDuringWrite: streamedSnapshot && hasLocators,
+ initialTotalRows: selected.rows.length,
+ prepare: async () => {
+ if (!isCurrent()) throw new Error("LOB result context changed");
},
- );
- try {
- const formattedCells = selected.cells.filter((cell) => shouldApplyColumnFormatter(sourceIndexes[cell.columnIndex]!));
- if (formattedCells.length) {
- selected.rows = await materializeSnapshotResultRows(
- {
- ...original,
- rows: selected.rows as CellValue[][],
- large_value_cells: formattedCells.map((cell) => ({ ...original.large_value_cells!.find((source) => source.value_ref === cell.valueRef)!, row_index: cell.rowIndex, column_index: cell.columnIndex })),
- },
+ cancel: () => cancel(true),
+ start: async (onProgress) => {
+ let nativeUnknown = false;
+ const progress = (status: api.TableExportProgress["status"], errorMessage?: string): api.TableExportProgress => ({
+ exportId: executionId,
+ tableName: title,
+ rowsExported: status === "Done" || status === "Writing" ? selected.rows.length : 0,
+ totalRows: selected.rows.length,
+ status,
+ errorMessage,
+ });
+ const readChunk: typeof api.readLargeValueChunk = async (request) => {
+ try {
+ return await (native ? api.readLargeValueChunk(request, true) : api.readLargeValueChunk(request));
+ } catch (error) {
+ nativeUnknown = native && (!(error instanceof SnapshotCompletionError) || error.status === "unknown");
+ throw error;
+ }
+ };
+ activeSnapshotCancels.add(cancelSource);
+ const stop = watch(
isCurrent,
- controller.signal,
- executionId,
+ (current) => {
+ if (!current) void cancelSource().catch(() => undefined);
+ },
+ { flush: "sync" },
);
- selected.cells = selected.cells.filter((cell) => !formattedCells.includes(cell));
- }
- selected.rows = selected.rows.map((row) => row.map((value, columnIndex) => externalCellValue(value as CellValue, exportAll ? sourceIndexes[columnIndex]! : (indexes?.[columnIndex] ?? columnIndex), sourceIndexes[columnIndex], true, !!exportAll)));
- selected.rows = applyGlobalDateTimeExportFormat({ columns: names, columnTypes: types, rows: selected.rows as CellValue[][] }, true, sourceIndexes).rows;
- controller.signal.throwIfAborted();
- if (!isCurrent()) throw new Error("LOB result context changed");
- await waitForLargeValueSnapshot(
- api.exportSnapshotResult({ ...selected, context: { ...selected.context, executionId }, format, quoteMode: useSettingsStore().editorSettings.csvQuoteMode, nullLiteral: csvNullLiteralForMode(useSettingsStore().editorSettings.csvNullMode) }, outputPath, controller.signal),
- controller.signal,
- );
- if (!isCurrent()) throw new Error("LOB result context changed");
- tracker.updateTableExportTask(executionId, { exportId: executionId, tableName: title, rowsExported: selected.rows.length, totalRows: selected.rows.length, status: "Done" });
- if (exportProgressState) exportProgressState.value = { ...exportProgressState.value, status: "Done", rowsExported: selected.rows.length, finishedAt: Date.now() };
- notifyExportSuccess(outputPath);
- } catch (error) {
- const errorMessage = error instanceof Error ? error.message : String(error);
- tracker.updateTableExportTask(executionId, { exportId: executionId, tableName: title, rowsExported: 0, totalRows: selected.rows.length, status: "Error", errorMessage });
- if (exportProgressState) exportProgressState.value = { ...exportProgressState.value, status: "Error", errorMessage, finishedAt: Date.now() };
- throw error;
- } finally {
- stop();
- if (activeSnapshotCancel === cancel) activeSnapshotCancel = undefined;
- tracker.unregisterTaskCancelHandler(executionId);
- if (exportCanMinimize) exportCanMinimize.value = false;
- if (exportCancelHandler) exportCancelHandler.value = previousCancel ?? null;
- }
+ try {
+ if (!isCurrent()) throw new Error("LOB result context changed");
+ if (resolveLegacy) {
+ let resolved: Map<number, Map<number, CellValue>>;
+ try {
+ resolved = await resolveLegacy(controller.signal);
+ } catch (error) {
+ nativeUnknown = !(error instanceof SnapshotCompletionError) || error.status === "unknown";
+ throw error;
+ }
+ for (const cell of legacyCells) {
+ const values = resolved.get(cell.rowId);
+ if (!values?.has(cell.columnIndex)) throw new Error("Export large value is unavailable");
+ const value = values.get(cell.columnIndex)!;
+ selected.rows[cell.rowIndex]![cell.targetColumnIndex] = formatterDisplay && formattedLegacyCells.includes(cell) ? formatterDisplay(value, cell.columnIndex) : value;
+ }
+ materializationResult.rows = selected.rows as CellValue[][];
+ }
+ if (materializedCells.length) {
+ selected.rows = await materializeSnapshotResultRows(materializationResult, isCurrent, controller.signal, executionId, { waitForNative: native, readChunk });
+ if (formatterDisplay)
+ for (const cell of formattedCells) {
+ const row = selected.rows[cell.rowIndex]!;
+ row[cell.columnIndex] = formatterDisplay(row[cell.columnIndex] as CellValue, sourceIndexes[cell.columnIndex]!);
+ }
+ selected.cells = selected.cells.filter((cell) => !materializedCells.includes(cell));
+ }
+ controller.signal.throwIfAborted();
+ if (!isCurrent()) throw new Error("LOB result context changed");
+ if (writeWorkbook) assertSnapshotXlsxCellLengths(selected.rows as CellValue[][]);
+ onProgress(progress("Writing"));
+ let writing: Promise<void>;
+ if (format === "csv" && !hasLocators) writing = api.exportQueryResultCsv(outputPath, names, selected.rows as CellValue[][], editorSettings.csvQuoteMode, csvNullLiteralForMode(editorSettings.csvNullMode));
+ else if (format === "json" && !hasLocators) writing = api.exportQueryResultJson(outputPath, names, selected.rows as CellValue[][]);
+ else if (format === "csv" || format === "json") {
+ const request = { ...selected, context: { ...selected.context, executionId }, format, quoteMode: editorSettings.csvQuoteMode, nullLiteral: csvNullLiteralForMode(editorSettings.csvNullMode) };
+ writing = native ? api.exportSnapshotResult(request, outputPath, undefined, true) : api.exportSnapshotResult(request, outputPath, controller.signal);
+ } else if (writeWorkbook) writing = writeWorkbook(outputPath, { columns: names, columnTypes: types, columnComments: xlsxComments, rows: selected.rows as CellValue[][] });
+ else if (format === "markdown") writing = api.exportQueryResultMarkdown(outputPath, names, selected.rows as CellValue[][]);
+ else if (format === "html") writing = api.exportQueryResultHtml(outputPath, title, names, selected.rows as CellValue[][]);
+ else {
+ const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+ controller.signal.throwIfAborted();
+ let content: string;
+ if (projectSql && insertOptions) {
+ try {
+ content = await formatSqlInsert({ ...insertOptions, ...projectSql(selected.rows as CellValue[][]) });
+ } catch (error) {
+ nativeUnknown = true;
+ throw error;
+ }
+ } else content = formatTsv(names, selected.rows as CellValue[][]);
+ controller.signal.throwIfAborted();
+ writing = writeTextFile(outputPath, content);
+ }
+ if (native) {
+ try {
+ await writing;
+ } catch (error) {
+ nativeUnknown = !(error instanceof SnapshotCompletionError) || error.status === "unknown";
+ throw error;
+ }
+ } else {
+ await waitForLargeValueSnapshot(writing, controller.signal);
+ if (!isCurrent()) throw new Error("LOB result context changed");
+ }
+ const done = progress("Done");
+ onProgress(done);
+ return done;
+ } catch (error) {
+ if (nativeUnknown) throw error;
+ if (native && ((error instanceof SnapshotCompletionError && error.status === "cancelled") || (controller.signal.aborted && userCancelled && error === controller.signal.reason))) {
+ const cancelled = progress("Cancelled");
+ onProgress(cancelled);
+ return cancelled;
+ }
+ onProgress(progress("Error", error instanceof Error ? error.message : String(error)));
+ throw error;
+ } finally {
+ if (!nativeUnknown) {
+ stop();
+ activeSnapshotCancels.delete(cancelSource);
+ }
+ }
+ },
+ });
+ return true;
+ }
+
+ async function exportMemoryDataFile(
+ format: "csv" | "json" | "markdown" | "html" | "txt" | "xlsx" | "sql",
+ rowIds: number[] | undefined,
+ columnIndexes: number[] | undefined,
+ full: boolean,
+ exportOptions: { xlsx?: XlsxExportOptions; includeSqlSheet?: boolean; sql?: SqlExportOptions; openAfterExport?: boolean } = {},
+ ): Promise<boolean> {
+ const original = completeLocalResult?.value ?? options.snapshotResult?.value;
+ if (!isTauriRuntime() || !original) return false;
+ const needsFullRead = full && rowIds === undefined && !hasCompleteLocalResult?.value;
+ const readFull = needsFullRead ? options.captureFullExportResult?.() : undefined;
+ if (needsFullRead && !readFull) throw new Error("Export source cannot be captured");
+ const visibleIndexes = visibleColumnIndexesOption?.value ?? columns.value.map((_, index) => index);
+ const indexes = (columnIndexes ?? columns.value.map((_, index) => index)).filter((index) => index >= 0 && index < columns.value.length);
+ const sourceIndexes = new Set(full && rowIds === undefined && columnIndexes === undefined ? original.columns.map((_, index) => index).filter((index) => !original.hidden_column_indexes?.includes(index)) : indexes.map((index) => visibleIndexes[index] ?? index));
+ const selectedItems = full && rowIds === undefined ? undefined : rowsToExport(rowIds);
+ const settings = { ...useSettingsStore().editorSettings };
+ const hasSelectedPreview = original.large_value_cells?.some((cell) => {
+ if (!sourceIndexes.has(cell.column_index)) return false;
+ if (!selectedItems) return !settings.exportRowLimitEnabled || cell.row_index < settings.exportRowLimit;
+ return selectedItems.some((item) => !item.isNew && item.sourceIndex === cell.row_index && indexes.some((index) => (visibleIndexes[index] ?? index) === cell.column_index && !item.isDirtyCol[index]));
+ });
+ if (!needsFullRead && hasSelectedPreview) return false;
+ const originalConnection = connectionId.value;
+ const originalDatabase = database.value;
+ const title = currentExportTitle();
+ const { xlsx: xlsxOptions, sql: sqlOptions, includeSqlSheet = false } = exportOptions;
+ const writeWorkbook = format === "xlsx" ? captureXlsxWriter(includeSqlSheet, xlsxOptions?.autoFilter ?? false, full ? undefined : currentPageExportSql(), xlsxHeaderUsesCommentRows(xlsxOptions?.headerMode ?? "name")) : undefined;
+ const meta = FORMAT_META[format]!;
+ const fileName = full && (format === "txt" || format === "sql") ? exportFileName(tableMeta.value?.tableName || "export", meta.ext, { preferFallback: true }) : exportFileName(full ? "export" : "export-page", meta.ext, { page: !full });
+ const projectFull = needsFullRead ? captureFullResultProjection(columnIndexes, format !== "sql", xlsxOptions?.headerMode ?? "name", format === "json") : undefined;
+ const sqlContext = format === "sql" ? captureSqlInsertContext() : undefined;
+ const selectedSqlColumns = sqlOptions?.selectedColumns?.map((column) => ({ ...column }));
+ const excludedColumns = captureSqlExportExcludedColumns();
+ const prepared = needsFullRead ? undefined : await resultToExport({ rowIds, columnIndexes }, undefined, full, format !== "sql", xlsxOptions?.headerMode ?? "name", format === "json", undefined, true);
+ if (prepared) prepared.rows = prepared.rows.map((row) => row.map((value) => (value !== null && typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value)));
+ const insertTarget = format === "sql" ? sqlInsertTargetMeta() : undefined;
+ const insertOptions =
+ format === "sql"
+ ? {
+ databaseType: databaseType.value,
+ identifierQuote: options.identifierQuote?.value,
+ schema: sqlInsertTargetSchema(insertTarget),
+ tableName: sqlInsertTargetName(insertTarget),
+ insertMode: sqlOptions?.insertMode,
+ }
+ : undefined;
+ const isCurrent = () => !scopeDisposed && (completeLocalResult?.value ?? options.snapshotResult?.value) === original && connectionId.value === originalConnection && database.value === originalDatabase;
+ if (!isCurrent()) throw new Error("Export result context changed");
+ const mode = exportOptions.openAfterExport ? "immediate" : (xlsxOptions?.executionMode ?? sqlOptions?.executionMode ?? (await showExportExecutionModeDialog()));
+ if (mode === null) return true;
+ const outputPath = exportOptions.openAfterExport ? await api.createQueryResultTempFile(meta.ext) : await promptExportSavePath({ defaultFileName: fileName, filters: [{ name: meta.label, extensions: [meta.ext] }], preferredPath: settings.preferredExportPath });
+ if (!outputPath) return true;
+ if (!isCurrent()) throw new Error("Export result context changed");
+ const exportId = uuid();
+ const controller = new AbortController();
+ await submitBackendExport({
+ exportId,
+ tableName: title,
+ format,
+ outputPath,
+ mode,
+ openAfterExport: exportOptions.openAfterExport === true,
+ initialTotalRows: prepared?.rows.length ?? null,
+ cancelDuringWrite: false,
+ ...(readFull
+ ? {
+ cancel: async () => {
+ controller.abort();
+ },
+ }
+ : {}),
+ start: async (onProgress) => {
+ let result = prepared;
+ if (readFull && projectFull) {
+ let reading = true;
+ try {
+ const fetched = await readFull((info) => onProgress({ exportId, tableName: title, ...info, status: "Running" }), { signal: controller.signal });
+ reading = false;
+ if (fetched?.execution_error) throw new SnapshotCompletionError(fetched.error?.operationOutcome === "not_started" ? "failed" : "unknown", "Export query failed");
+ if (controller.signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ if (!fetched || fetched.large_value_cells?.length) throw new Error("Export source is incomplete");
+ result = projectFull(fetched);
+ } catch (error) {
+ if ((error instanceof SnapshotCompletionError && error.status === "unknown") || (reading && !(error instanceof SnapshotCompletionError))) throw error;
+ const status = error instanceof SnapshotCompletionError && error.status === "cancelled" ? "Cancelled" : "Error";
+ const progress: api.TableExportProgress = { exportId, tableName: title, rowsExported: 0, totalRows: null, status, errorMessage: error instanceof Error ? error.message : String(error) };
+ onProgress(progress);
+ return progress;
+ }
+ }
+ if (!result) throw new Error("Export source is unavailable");
+ const sqlData = insertOptions ? captureSqlInsertExportData(result, selectedSqlColumns, sqlContext)(result.rows) : undefined;
+ onProgress({ exportId, tableName: title, rowsExported: result.rows.length, totalRows: result.rows.length, status: "Writing" });
+ if (writeWorkbook) await writeWorkbook(outputPath, result);
+ else if (format === "csv") await api.exportQueryResultCsv(outputPath, result.columns, result.rows, settings.csvQuoteMode, csvNullLiteralForMode(settings.csvNullMode));
+ else if (format === "json") await api.exportQueryResultJson(outputPath, result.columns, result.rows);
+ else if (format === "markdown") await api.exportQueryResultMarkdown(outputPath, result.columns, result.rows);
+ else if (format === "html") await api.exportQueryResultHtml(outputPath, title, result.columns, result.rows);
+ else {
+ const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+ await writeTextFile(outputPath, insertOptions && sqlData ? await formatSqlInsert({ ...insertOptions, ...sqlData, excludeColumns: excludedColumns(sqlData.columns) }) : formatTsv(result.columns, result.rows));
+ }
+ return { exportId, tableName: title, rowsExported: result.rows.length, totalRows: result.rows.length, status: "Done" };
+ },
+ });
return true;
}
@@ -1169,6 +1486,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
if (await exportLocalSnapshot("csv", rowIds, columnIndexes, true)) return;
if (await exportQueryResultViaBackend("csv", rowIds, false, "name", true, undefined, false, columnIndexes)) return;
if (await exportFullTableDataViaBackend("csv", rowIds, "name", true, undefined, false, columnIndexes)) return;
+ if (await exportMemoryDataFile("csv", rowIds, columnIndexes, true)) return;
const needsFullExport = rowIds === undefined && !!fullExportResult && !hasCompleteLocalResult?.value;
if (needsFullExport && exportProgressDialog && exportProgressState) {
@@ -1234,7 +1552,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
}
notifyExportSuccess(outputPath);
} catch (e: any) {
- if (exportProgressState) {
+ if (exportProgressState && exportProgressState.value.status !== "Unknown") {
exportProgressState.value = {
...exportProgressState.value,
status: "Error",
@@ -1250,6 +1568,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
await runExclusiveExport(async () => {
try {
if (await exportLocalSnapshot("csv", undefined, columnIndexes, false)) return;
+ if (await exportMemoryDataFile("csv", undefined, columnIndexes, false)) return;
let outputPath = exportFileName("export-page", "csv", { page: true });
if (isTauriRuntime()) {
const path = await promptExportSavePath({
@@ -1276,6 +1595,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
if (await exportLocalSnapshot("json", rowIds, columnIndexes, true)) return;
if (await exportFullTableDataViaBackend("json", rowIds, "name", true, undefined, false, columnIndexes)) return;
if (await exportQueryResultViaBackend("json", rowIds, false, "name", true, undefined, false, columnIndexes)) return;
+ if (await exportMemoryDataFile("json", rowIds, columnIndexes, true)) return;
let outputPath = exportFileName("export", "json");
if (isTauriRuntime()) {
@@ -1300,6 +1620,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
await runExclusiveExport(async () => {
try {
if (await exportLocalSnapshot("json", undefined, columnIndexes, false)) return;
+ if (await exportMemoryDataFile("json", undefined, columnIndexes, false)) return;
let outputPath = exportFileName("export-page", "json", { page: true });
if (isTauriRuntime()) {
const path = await promptExportSavePath({
@@ -1324,6 +1645,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
await runExclusiveExport(async () => {
try {
if (await exportFullTableDataViaBackend("markdown", rowIds, "name", true, undefined, false, columnIndexes)) return;
+ if (await exportLocalSnapshot("markdown", rowIds, columnIndexes, true)) return;
+ if (await exportMemoryDataFile("markdown", rowIds, columnIndexes, true)) return;
let outputPath = exportFileName("export", "md");
if (isTauriRuntime()) {
@@ -1347,6 +1670,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
async function exportCurrentPageMarkdown(columnIndexes?: number[]) {
await runExclusiveExport(async () => {
try {
+ if (await exportLocalSnapshot("markdown", undefined, columnIndexes, false)) return;
+ if (await exportMemoryDataFile("markdown", undefined, columnIndexes, false)) return;
let outputPath = exportFileName("export-page", "md", { page: true });
if (isTauriRuntime()) {
const path = await promptExportSavePath({
@@ -1372,6 +1697,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
try {
if (await exportQueryResultViaBackend("txt", rowIds, false, "name", true, undefined, false, columnIndexes)) return;
if (await exportFullTableDataViaBackend("txt", rowIds, "name", true, undefined, false, columnIndexes)) return;
+ if (await exportLocalSnapshot("txt", rowIds, columnIndexes, true)) return;
+ if (await exportMemoryDataFile("txt", rowIds, columnIndexes, true)) return;
const result = await resultToExport({ rowIds, columnIndexes });
const content = formatTsv(result.columns, result.rows);
const saved = await saveTextFile(content, exportFileName(tableMeta.value?.tableName || "export", "txt", { preferFallback: true }), "Text", "txt");
@@ -1387,6 +1714,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const { rowIds, columnIndexes } = normalizeExportTarget(target, columnIndexesParam);
await runExclusiveExport(async () => {
try {
+ if (await exportLocalSnapshot("html", rowIds, columnIndexes, true, { openAfterExport })) return;
+ if (await exportMemoryDataFile("html", rowIds, columnIndexes, true, { openAfterExport })) return;
let outputPath = exportFileName("export", "html");
if (isTauriRuntime()) {
if (openAfterExport) outputPath = await api.createQueryResultTempFile("html");
@@ -1413,6 +1742,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
async function exportCurrentPageHtml(columnIndexes?: number[]) {
await runExclusiveExport(async () => {
try {
+ if (await exportLocalSnapshot("html", undefined, columnIndexes, false)) return;
+ if (await exportMemoryDataFile("html", undefined, columnIndexes, false)) return;
let outputPath = exportFileName("export-page", "html", { page: true });
if (isTauriRuntime()) {
const path = await promptExportSavePath({
@@ -1435,6 +1766,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
async function exportCurrentPageTxt(columnIndexes?: number[]) {
await runExclusiveExport(async () => {
try {
+ if (await exportLocalSnapshot("txt", undefined, columnIndexes, false)) return;
+ if (await exportMemoryDataFile("txt", undefined, columnIndexes, false)) return;
const result = await resultToExport({ columnIndexes }, undefined, false);
const content = formatTsv(result.columns, result.rows);
const saved = await saveTextFile(content, exportFileName("export-page", "txt", { page: true }), "Text", "txt");
@@ -1448,13 +1781,17 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
async function exportXlsxResult(target?: ExportTargetParam, includeSqlSheet = false, openAfterExport = false, columnIndexesParam?: number[]) {
const { rowIds, columnIndexes } = normalizeExportTarget(target, columnIndexesParam);
- const exportOptions = await showXlsxHeaderDialog();
+ const isSourceCurrent = captureExportConfirmationSource();
+ const exportOptions = await showXlsxHeaderDialog(isTauriRuntime() && !openAfterExport);
if (exportOptions === null) return;
await runExclusiveExport(async () => {
try {
- if (await exportQueryResultViaBackend("xlsx", rowIds, includeSqlSheet, exportOptions.headerMode, exportOptions.autoFilter, undefined, openAfterExport, columnIndexes)) return;
- if (await exportFullTableDataViaBackend("xlsx", rowIds, exportOptions.headerMode, exportOptions.autoFilter, undefined, openAfterExport, columnIndexes)) return;
+ if (isTauriRuntime() && !isSourceCurrent()) throw new Error("Export result context changed");
+ if (await exportQueryResultViaBackend("xlsx", rowIds, includeSqlSheet, exportOptions.headerMode, exportOptions.autoFilter, undefined, openAfterExport, columnIndexes, exportOptions.executionMode)) return;
+ if (await exportFullTableDataViaBackend("xlsx", rowIds, exportOptions.headerMode, exportOptions.autoFilter, undefined, openAfterExport, columnIndexes, exportOptions.executionMode)) return;
+ if (await exportLocalSnapshot("xlsx", rowIds, columnIndexes, true, { xlsx: exportOptions, includeSqlSheet, openAfterExport })) return;
+ if (await exportMemoryDataFile("xlsx", rowIds, columnIndexes, true, { xlsx: exportOptions, includeSqlSheet, openAfterExport })) return;
let outputPath = exportFileName("export", "xlsx");
if (isTauriRuntime()) {
@@ -1553,11 +1890,15 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
}
async function exportCurrentPageXlsxResult(includeSqlSheet: boolean, columnIndexes?: number[]) {
- const exportOptions = await showXlsxHeaderDialog();
+ const isSourceCurrent = captureExportConfirmationSource();
+ const exportOptions = await showXlsxHeaderDialog(isTauriRuntime());
if (exportOptions === null) return;
await runExclusiveExport(async () => {
try {
+ if (isTauriRuntime() && !isSourceCurrent()) throw new Error("Export result context changed");
+ if (await exportLocalSnapshot("xlsx", undefined, columnIndexes, false, { xlsx: exportOptions, includeSqlSheet })) return;
+ if (await exportMemoryDataFile("xlsx", undefined, columnIndexes, false, { xlsx: exportOptions, includeSqlSheet })) return;
let outputPath = exportFileName("export-page", "xlsx", { page: true });
if (isTauriRuntime()) {
const path = await promptExportSavePath({
@@ -1585,7 +1926,199 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
await exportCurrentPageXlsxResult(true, columnIndexes);
}
- async function exportResultSheetsXlsxResult(sheetsToExport: Array<{ sheetName: string; result: QueryResult; sql?: string }> | undefined, includeSqlSheet: boolean) {
+ async function exportMemoryResultSheetsXlsx(sheetsToExport: DataGridExportSheet[] | undefined, includeSqlSheet: boolean): Promise<boolean> {
+ if (!isTauriRuntime()) return false;
+ const sheets = (sheetsToExport ?? allExportResults?.value ?? []).filter((sheet) => sheet.result.columns.length > 0);
+ if (!sheets.length) return true;
+ const sourceCurrent = captureExportConfirmationSource();
+ const sources = sheets.map((sheet) => ({ sheet, result: sheet.result, rows: sheet.result.rows }));
+ const isCurrent = () => sourceCurrent() && sources.every(({ sheet, result, rows }) => sheet.result === result && sheet.result.rows === rows && (sheetsToExport !== undefined || !!allExportResults?.value?.includes(sheet)));
+ const settings = { ...useSettingsStore().editorSettings };
+ const title = currentExportTitle();
+ const fileName = exportFileName("query-results", "xlsx", { allResults: true });
+ const captured = sheets.map((sheet) => ({
+ sheetName: sheet.sheetName,
+ columns: [...sheet.result.columns],
+ columnTypes: [...(sheet.result.column_types ?? [])],
+ comments: commentsForExportColumns(sheet.result.columns),
+ rows: formatTemporalRowsForExport(
+ sheet.result.rows.map((row) => row.map((value) => (value !== null && typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value))),
+ sheet.result.column_types ?? [],
+ settings.globalDateTimeExportFormat,
+ ),
+ sql: sheet.sql || sheet.result.sourceStatement || "",
+ legacyCells: sheet.result.large_value_cells?.filter((cell) => !cell.value_ref).map((cell) => ({ ...cell })) ?? [],
+ legacyRead: sheet.result.large_value_cells?.some((cell) => !cell.value_ref) ? sheet.captureSourceValues?.() : undefined,
+ snapshot: {
+ ...sheet.result,
+ rows: sheet.result.rows.map((row) => row.map((value) => (value !== null && typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value))),
+ large_value_cells: sheet.result.large_value_cells?.map((cell) => ({ ...cell })),
+ large_value_context: sheet.result.large_value_context ? { ...sheet.result.large_value_context } : undefined,
+ },
+ }));
+ const lobSources = sources.filter(({ result }) => result.large_value_cells?.some((cell) => cell.value_ref));
+ const connections = lobSources.length && getActivePinia() ? useConnectionStore() : undefined;
+ const resources = lobSources.map(({ result }) => {
+ const context = result.large_value_context;
+ if (!context) throw new Error("LOB result connection is unavailable; execute the query again");
+ const config = connections?.getConfig(context.connectionId);
+ return { connectionId: context.connectionId, revision: connections?.connectionStateRevision(context.connectionId), fingerprint: config ? connectionConfigFingerprint(config) : undefined };
+ });
+ const resourcesCurrent = () =>
+ !scopeDisposed &&
+ sourceCurrent() &&
+ lobSources.every(({ sheet, result, rows }) => sheet.result === result && result.rows === rows && (sheetsToExport !== undefined || !!allExportResults?.value?.includes(sheet))) &&
+ resources.every((resource) => {
+ if (!connections) return true;
+ const config = connections.getConfig(resource.connectionId);
+ return connections.isCurrentConnectionStateRevision(resource.connectionId, resource.revision!) && !!config && connectionConfigFingerprint(config) === resource.fingerprint;
+ });
+ const exportOptions = await showXlsxHeaderDialog(true);
+ if (exportOptions === null) return true;
+ if (!isCurrent()) throw new Error("Export result context changed");
+ const mode = exportOptions.executionMode ?? (await showExportExecutionModeDialog());
+ if (mode === null) return true;
+ const outputPath = await promptExportSavePath({ defaultFileName: fileName, filters: [{ name: "Excel", extensions: ["xlsx"] }], preferredPath: settings.preferredExportPath });
+ if (!outputPath) return true;
+ if (!isCurrent()) throw new Error("Export result context changed");
+ const worksheets = captured.map((sheet) => ({
+ sheetName: sheet.sheetName,
+ columns: sheet.columns,
+ columnTypes: sheet.columnTypes,
+ columnComments: buildXlsxHeaderOverrides(sheet.columns, sheet.comments, exportOptions.headerMode),
+ rows: sheet.rows,
+ numericColumnRightAlign: settings.numericColumnRightAlign,
+ autoFilter: exportOptions.autoFilter,
+ headerCommentRows: xlsxHeaderUsesCommentRows(exportOptions.headerMode),
+ }));
+ const sqlWorksheet = includeSqlSheet ? buildXlsxSqlWorksheet(captured.map((sheet) => ({ resultName: sheet.sheetName, sql: sheet.sql }))) : undefined;
+ const exportId = uuid();
+ const totalRows = worksheets.reduce((count, sheet) => count + sheet.rows.length, 0);
+ const controller = new AbortController();
+ const hasDeferredReads = lobSources.length > 0 || captured.some((sheet) => sheet.legacyCells.length);
+ let userCancelled = false;
+ let locatorReading = false;
+ const cancel = async (user = true) => {
+ if (!controller.signal.aborted) userCancelled = user;
+ controller.abort(new Error("LOB workbook export cancelled"));
+ if (locatorReading) await api.cancelQuery(exportId);
+ };
+ const cancelSource = () => cancel(false);
+ await submitBackendExport({
+ exportId,
+ tableName: title,
+ format: "xlsx",
+ outputPath,
+ mode,
+ openAfterExport: false,
+ initialTotalRows: totalRows,
+ cancelDuringWrite: false,
+ ...(hasDeferredReads
+ ? {
+ cancel,
+ prepare: async () => {
+ for (const sheet of captured) if (sheet.legacyCells.length && (!sheet.legacyRead?.read || sheet.legacyRead.unavailableReason)) throw new Error(`${sheet.sheetName}: ${sheet.legacyRead?.unavailableReason ?? "Original table source is unavailable; execute the query again"}`);
+ if (lobSources.length && !resourcesCurrent()) throw new Error("LOB result context changed");
+ },
+ }
+ : {}),
+ start: async (onProgress) => {
+ let unknown = false;
+ const readChunk: typeof api.readLargeValueChunk = async (request) => {
+ try {
+ return await api.readLargeValueChunk(request, true);
+ } catch (error) {
+ unknown ||= !(error instanceof SnapshotCompletionError) || error.status === "unknown";
+ throw error;
+ }
+ };
+ const stop = lobSources.length
+ ? watch(
+ resourcesCurrent,
+ (current) => {
+ if (!current) void cancelSource().catch(() => undefined);
+ },
+ { flush: "sync" },
+ )
+ : undefined;
+ if (hasDeferredReads) activeSnapshotCancels.add(cancelSource);
+ try {
+ for (let index = 0; index < captured.length; index++) {
+ const sheet = captured[index]!;
+ if (!sheet.snapshot.large_value_cells?.length) continue;
+ try {
+ if (sheet.legacyCells.length) {
+ let values;
+ try {
+ values = await sheet.legacyRead!.read!(controller.signal);
+ } catch (error) {
+ unknown ||= !(error instanceof SnapshotCompletionError) || error.status === "unknown";
+ throw error;
+ }
+ for (const cell of sheet.legacyCells) {
+ const row = values.get(cell.row_index);
+ if (!row?.has(cell.column_index)) throw new Error(`${sheet.sheetName}: complete cell value is unavailable`);
+ sheet.snapshot.rows[cell.row_index]![cell.column_index] = row.get(cell.column_index)!;
+ }
+ sheet.snapshot.large_value_cells = sheet.snapshot.large_value_cells?.filter((cell) => !!cell.value_ref);
+ }
+ let rows = sheet.snapshot.rows;
+ if (sheet.snapshot.large_value_cells?.length) {
+ locatorReading = true;
+ try {
+ rows = await materializeSnapshotResultRows(sheet.snapshot, resourcesCurrent, controller.signal, exportId, { waitForNative: true, readChunk });
+ } finally {
+ locatorReading = false;
+ }
+ }
+ if (controller.signal.aborted) throw controller.signal.reason;
+ assertSnapshotXlsxCellLengths(rows);
+ worksheets[index]!.rows = formatTemporalRowsForExport(rows, sheet.columnTypes, settings.globalDateTimeExportFormat);
+ } catch (error) {
+ if (unknown) throw error;
+ const cancelled = userCancelled && ((error instanceof SnapshotCompletionError && error.status === "cancelled") || error === controller.signal.reason);
+ const progress: api.TableExportProgress = { exportId, tableName: title, rowsExported: 0, totalRows, status: cancelled ? "Cancelled" : "Error", errorMessage: error instanceof Error ? error.message : String(error) };
+ onProgress(progress);
+ return progress;
+ }
+ }
+ onProgress({ exportId, tableName: title, rowsExported: totalRows, totalRows, status: "Writing" });
+ try {
+ await api.exportQueryResultsXlsx(outputPath, sqlWorksheet ? [...worksheets, { ...sqlWorksheet, autoFilter: false }] : worksheets, exportOptions.autoFilter, settings.globalDateTimeExportFormat || undefined);
+ } catch (error) {
+ unknown = true;
+ throw error;
+ }
+ return { exportId, tableName: title, rowsExported: totalRows, totalRows, status: "Done" };
+ } finally {
+ if (!unknown) {
+ stop?.();
+ activeSnapshotCancels.delete(cancelSource);
+ }
+ }
+ },
+ });
+ return true;
+ }
+
+ async function exportResultSheetsXlsxResult(sheetsToExport: DataGridExportSheet[] | undefined, includeSqlSheet: boolean) {
+ if (isTauriRuntime()) {
+ let handled = false;
+ await runExclusiveExport(async () => {
+ try {
+ handled = await exportMemoryResultSheetsXlsx(sheetsToExport, includeSqlSheet);
+ } catch (error) {
+ handled = true;
+ toast(t("grid.exportFailed", { message: translateBackendError(t, error) }), 5000);
+ }
+ });
+ if (!handled) await exportResultSheetsXlsxFallback(sheetsToExport, includeSqlSheet);
+ return;
+ }
+ await exportResultSheetsXlsxFallback(sheetsToExport, includeSqlSheet);
+ }
+
+ async function exportResultSheetsXlsxFallback(sheetsToExport: DataGridExportSheet[] | undefined, includeSqlSheet: boolean) {
const exportOptions = await showXlsxHeaderDialog();
if (exportOptions === null) return;
@@ -1642,13 +2175,20 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
/** SQL 文件导出与 SQL INSERT 复制共用同一主键处理模式。 */
function sqlExportExcludedColumns(columnNames?: readonly string[]): string[] | undefined {
+ return captureSqlExportExcludedColumns()(columnNames);
+ }
+
+ function captureSqlExportExcludedColumns() {
const mode = extractorOptionsOption?.value?.sql.primaryKeyMode ?? "include";
- if (mode === "include") return undefined;
- const primaryKeys = tableMeta.value?.primaryKeys ?? [];
+ if (mode === "include") return (_columnNames?: readonly string[]) => undefined;
+ const primaryKeys = [...(tableMeta.value?.primaryKeys ?? [])];
const excluded = mode === "exclude-all" ? primaryKeys : primaryKeys.filter((column) => isAutoGeneratedColumn(databaseType.value, column, tableMeta.value));
- const knownColumns = tableMeta.value?.columns?.length ? tableMeta.value.columns.map((column) => column.name) : allColumns.value;
- const projectedExcluded = columnNames ? columnNames.filter((column) => isSqlExportPrimaryKeyExcluded(databaseType.value, column, knownColumns, excluded)) : excluded;
- return projectedExcluded.length > 0 ? projectedExcluded : undefined;
+ const knownColumns = tableMeta.value?.columns?.length ? tableMeta.value.columns.map((column) => column.name) : [...allColumns.value];
+ const type = databaseType.value;
+ return (columnNames?: readonly string[]) => {
+ const projectedExcluded = columnNames ? columnNames.filter((column) => isSqlExportPrimaryKeyExcluded(type, column, knownColumns, excluded)) : excluded;
+ return projectedExcluded.length > 0 ? projectedExcluded : undefined;
+ };
}
/**
@@ -1704,7 +2244,16 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return false;
}
- async function exportFullTableDataViaBackend(format: "csv" | "xlsx" | "json" | "markdown" | "sql" | "txt", rowIds?: number[], headerMode: XlsxHeaderMode = "name", autoFilter = true, sqlExportOptions?: SqlExportOptions, openAfterExport = false, columnIndexes?: number[]): Promise<boolean> {
+ async function exportFullTableDataViaBackend(
+ format: "csv" | "xlsx" | "json" | "markdown" | "sql" | "txt",
+ rowIds?: number[],
+ headerMode: XlsxHeaderMode = "name",
+ autoFilter = true,
+ sqlExportOptions?: SqlExportOptions,
+ openAfterExport = false,
+ columnIndexes?: number[],
+ selectedMode?: ManualExportMode,
+ ): Promise<boolean> {
const meta = tableMeta.value;
// The backend table exporter currently builds two-part table names. External
// Doris/StarRocks catalogs need the data-tab paginator's three-part SQL.
@@ -1715,30 +2264,130 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return false;
}
+ const editorSettings = { ...useSettingsStore().editorSettings };
+ const exportId = uuid();
+ const exportedColumns = format === "sql" ? effectiveColumns(sourceColumns.value, columns.value).map((column, index) => column ?? columns.value[index]!) : [...columns.value];
+ const request: api.TableExportRequest = {
+ exportId,
+ connectionId: connectionId.value,
+ database: database.value,
+ schema: meta.schema,
+ identifierQuote: options.identifierQuote?.value,
+ tableName: meta.tableName,
+ filePath: "",
+ format,
+ ...(format === "sql" && sqlExportOptions
+ ? {
+ insertMode: sqlExportOptions.insertMode,
+ splitMaxMb: sqlExportOptions.splitMaxMb,
+ selectedColumns: sqlExportOptions.selectedColumns?.map((column) => ({ ...column })),
+ omitDatabaseQualifier: dropsSchemaQualifier(databaseType.value, options.includeDatabaseName?.value, meta.catalog),
+ }
+ : {}),
+ csvQuoteMode: editorSettings.csvQuoteMode,
+ nullLiteral: csvNullLiteralForMode(editorSettings.csvNullMode),
+ columns: exportedColumns,
+ columnTypes: columnTypes.value ? [...columnTypes.value] : undefined,
+ ...(format === "sql" ? { columnExtras: sqlExportColumnExtras(exportedColumns) } : {}),
+ columnComments: format === "xlsx" ? buildXlsxHeaderOverrides(columns.value, visibleXlsxColumnComments.value, headerMode) : undefined,
+ headerCommentRows: format === "xlsx" ? xlsxHeaderUsesCommentRows(headerMode) : undefined,
+ primaryKeys: meta.primaryKeys ? [...meta.primaryKeys] : undefined,
+ ...sqlExportPrimaryKeyOptions(format),
+ whereInput: whereInput.value,
+ orderBy: orderBy.value,
+ skipCount: false,
+ batchSize: exportBatchSize.value,
+ rowLimit: editorSettings.exportRowLimitEnabled ? editorSettings.exportRowLimit : null,
+ dateTimeFormat: editorSettings.globalDateTimeExportFormat || undefined,
+ numericColumnRightAlign: editorSettings.numericColumnRightAlign ?? true,
+ autoFilter: format === "xlsx" ? autoFilter : undefined,
+ };
+ const preparingStore = isTauriRuntime() && getActivePinia() ? useConnectionStore() : undefined;
+ const originalConfig = preparingStore?.getConfig(request.connectionId);
+ const fingerprint = originalConfig ? connectionConfigFingerprint(originalConfig) : undefined;
+ const mode = openAfterExport ? "immediate" : (selectedMode ?? sqlExportOptions?.executionMode ?? (await showExportExecutionModeDialog()));
+ if (mode === null) return true;
+ const connStore = mode === "queued" ? useConnectionStore() : undefined;
const fmt = FORMAT_META[format];
- const splitSqlOutput = format === "sql" && sqlExportOptions?.splitMaxMb !== undefined;
+ const splitSqlOutput = format === "sql" && request.splitMaxMb !== undefined;
const extension = splitSqlOutput ? "zip" : (fmt?.ext ?? format);
const filterName = splitSqlOutput ? "ZIP" : (fmt?.label ?? format.toUpperCase());
- let outputPath = exportFileName(meta.tableName || "export", extension, { preferFallback: true });
+ let outputPath = exportFileName(request.tableName || "export", extension, { preferFallback: true });
if (openAfterExport && isTauriRuntime()) {
outputPath = await api.createQueryResultTempFile(extension);
} else if (isTauriRuntime()) {
const path = await promptExportSavePath({
defaultFileName: outputPath,
filters: [{ name: filterName, extensions: [extension] }],
- preferredPath: useSettingsStore().editorSettings.preferredExportPath,
+ preferredPath: editorSettings.preferredExportPath,
});
if (!path) return true;
outputPath = path;
}
+ if (scopeDisposed || connectionId.value !== request.connectionId || database.value !== request.database || tableMeta.value?.tableName !== request.tableName || tableMeta.value?.schema !== request.schema) {
+ toast(t("exportProgress.connectionChanged"), 5000);
+ return true;
+ }
+ request.filePath = outputPath;
+ await submitBackendExport({
+ exportId,
+ tableName: request.tableName,
+ format,
+ outputPath,
+ mode,
+ openAfterExport,
+ start: (onProgress) => (isTauriRuntime() ? api.startTableExport(request, onProgress, true) : api.startTableExport(request, onProgress)),
+ cancel: () => api.cancelTableExport(exportId),
+ prepare: connStore
+ ? async () => {
+ const assertCurrent = () => {
+ const current = connStore.getConfig(request.connectionId);
+ if (!current || connectionConfigFingerprint(current) !== fingerprint) throw new Error(t("exportProgress.connectionChanged"));
+ };
+ assertCurrent();
+ await connStore.ensureConnected(request.connectionId);
+ assertCurrent();
+ }
+ : undefined,
+ });
+ return true;
+ }
+
+ async function submitBackendExport({
+ exportId,
+ tableName,
+ format,
+ outputPath,
+ mode,
+ openAfterExport,
+ initialTotalRows = null,
+ prepare,
+ start,
+ cancel,
+ cancelDuringWrite = true,
+ }: {
+ exportId: string;
+ tableName: string;
+ format: string;
+ outputPath: string;
+ mode: ManualExportMode;
+ openAfterExport: boolean;
+ initialTotalRows?: number | null;
+ prepare?: () => Promise<void>;
+ start: (onProgress: (progress: api.TableExportProgress) => void) => Promise<api.TableExportProgress>;
+ cancel?: () => Promise<void>;
+ cancelDuringWrite?: boolean;
+ }): Promise<void> {
+ currentExportViewId = exportId;
+
if (exportProgressState) {
exportProgressState.value = {
title: t("exportProgress.title"),
- tableName: meta.tableName,
+ tableName,
format,
rowsExported: 0,
- totalRows: null,
+ totalRows: initialTotalRows,
status: "Running",
errorMessage: null,
filePath: outputPath,
@@ -1749,77 +2398,96 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
if (exportProgressDialog) exportProgressDialog.value = true;
if (exportCanMinimize) exportCanMinimize.value = true;
- const task = tracker.addTask(meta.tableName, format, outputPath);
- const exportId = task.exportId;
+ const task = tracker.addTask(tableName, format, outputPath, exportId);
+ task.totalRows = initialTotalRows;
if (exportCancelHandler) {
- exportCancelHandler.value = () => api.cancelTableExport(exportId);
+ exportCancelHandler.value = () => tracker.cancelTask(exportId);
}
- tracker.registerTaskCancelHandler(exportId, () => api.cancelTableExport(exportId));
- const editorSettings = useSettingsStore().editorSettings;
- const rowLimit = editorSettings.exportRowLimitEnabled ? editorSettings.exportRowLimit : null;
-
- try {
- const progress = await api.startTableExport(
- {
- exportId,
- connectionId: connectionId.value,
- database: database.value,
- schema: meta.schema,
- identifierQuote: options.identifierQuote?.value,
- tableName: meta.tableName,
- filePath: outputPath,
- format,
- ...(format === "sql" && sqlExportOptions
- ? {
- insertMode: sqlExportOptions.insertMode,
- splitMaxMb: sqlExportOptions.splitMaxMb,
- selectedColumns: sqlExportOptions.selectedColumns,
- omitDatabaseQualifier: dropsSchemaQualifier(databaseType.value, options.includeDatabaseName?.value, meta.catalog),
- }
- : {}),
- csvQuoteMode: editorSettings.csvQuoteMode,
- nullLiteral: csvNullLiteralForMode(editorSettings.csvNullMode),
- columns: format === "sql" ? effectiveColumns(sourceColumns.value, columns.value).map((column, index) => column ?? columns.value[index]!) : columns.value,
- columnTypes: columnTypes.value,
- ...(format === "sql" ? { columnExtras: sqlExportColumnExtras(effectiveColumns(sourceColumns.value, columns.value).map((column, index) => column ?? columns.value[index]!)) } : {}),
- columnComments: format === "xlsx" ? buildXlsxHeaderOverrides(columns.value, visibleXlsxColumnComments.value, headerMode) : undefined,
- headerCommentRows: format === "xlsx" ? xlsxHeaderUsesCommentRows(headerMode) : undefined,
- primaryKeys: meta.primaryKeys,
- ...sqlExportPrimaryKeyOptions(format),
- whereInput: whereInput.value,
- orderBy: orderBy.value,
- skipCount: false,
- batchSize: exportBatchSize.value,
- rowLimit,
- dateTimeFormat: editorSettings.globalDateTimeExportFormat || undefined,
- numericColumnRightAlign: editorSettings.numericColumnRightAlign ?? true,
- autoFilter: format === "xlsx" ? autoFilter : undefined,
- },
- (progress) => {
- if (exportProgressState) {
+ const ownsView = () => !scopeDisposed && currentExportViewId === exportId;
+ const updateView = () => {
+ if (ownsView()) {
+ if (exportProgressState) exportProgressState.value = { ...exportProgressState.value, status: task.status, startedAt: task.startedAt, finishedAt: task.finishedAt, errorMessage: task.errorMessage };
+ if (exportCancelHandler) exportCancelHandler.value = task.canCancel === false || task.status === "Done" || task.status === "Error" || task.status === "Cancelled" ? null : () => tracker.cancelTask(exportId);
+ }
+ };
+ let executionError: unknown;
+ const execute = async (): Promise<"settled" | "unknown"> => {
+ let started = false;
+ let terminalSeen = false;
+ let cancellationRequested = false;
+ tracker.registerTaskCancelHandler(exportId, async () => {
+ cancellationRequested = true;
+ task.status = "Cancelling";
+ updateView();
+ if (started) await cancel?.();
+ });
+ try {
+ if (prepare) await prepare();
+ if (cancellationRequested) {
+ tracker.updateTableExportTask(exportId, { exportId, tableName, rowsExported: 0, totalRows: null, status: "Cancelled" });
+ updateView();
+ return "settled";
+ }
+ started = true;
+ task.canCancel = cancel !== undefined;
+ updateView();
+ const progress = await start((progress) => {
+ if (!cancelDuringWrite && progress.status === "Writing") {
+ task.canCancel = false;
+ updateView();
+ }
+ terminalSeen ||= progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled";
+ tracker.updateTableExportTask(exportId, progress);
+ if (ownsView() && exportProgressState) {
exportProgressState.value = {
...exportProgressState.value,
- tableName: progress.tableName || meta.tableName,
+ tableName: progress.tableName || tableName,
rowsExported: progress.rowsExported,
- totalRows: progress.totalRows,
- status: progress.status,
+ totalRows: progress.totalRows !== null && progress.rowsExported > progress.totalRows ? progress.rowsExported : progress.totalRows,
+ status: task.status,
errorMessage: progress.errorMessage || null,
finishedAt: progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled" ? Date.now() : exportProgressState.value.finishedAt,
};
}
- tracker.updateTableExportTask(exportId, progress);
- },
- );
- if (progress.status === "Done") {
- notifyExportSuccess(openAfterExport ? undefined : outputPath);
- if (openAfterExport && isTauriRuntime()) await api.openQueryResultTempFile(outputPath);
+ });
+ if (!terminalSeen) tracker.updateTableExportTask(exportId, progress);
+ terminalSeen ||= progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled";
+ if (progress.status === "Done") {
+ notifyExportSuccess(openAfterExport ? undefined : outputPath);
+ if (openAfterExport && isTauriRuntime()) await api.openQueryResultTempFile(outputPath);
+ }
+ return terminalSeen ? "settled" : "unknown";
+ } catch (error) {
+ executionError = error;
+ const confirmedFailure = error instanceof SnapshotCompletionError && error.status === "failed";
+ if (confirmedFailure) started = false;
+ if (started && !terminalSeen && isTauriRuntime() && !confirmedFailure) throw error;
+ if (terminalSeen && task.status === "Done") return "settled";
+ tracker.updateTableExportTask(exportId, { exportId, tableName, rowsExported: task.rowsExported, totalRows: task.totalRows, status: "Error", errorMessage: error instanceof Error ? error.message : String(error) });
+ updateView();
+ if (!started || terminalSeen || confirmedFailure) return "settled";
+ throw error;
+ } finally {
+ if (!isTauriRuntime() || !started || terminalSeen) {
+ tracker.unregisterTaskCancelHandler(exportId);
+ if (ownsView()) {
+ if (exportCancelHandler) exportCancelHandler.value = null;
+ if (exportCanMinimize) exportCanMinimize.value = false;
+ }
+ }
}
- } finally {
- if (exportCancelHandler) exportCancelHandler.value = null;
- tracker.unregisterTaskCancelHandler(exportId);
- if (exportCanMinimize) exportCanMinimize.value = false;
+ };
+ if (!isTauriRuntime()) {
+ await execute();
+ if (executionError !== undefined) throw executionError;
+ return;
+ }
+ let completion: Promise<"settled" | "unknown"> | undefined;
+ tracker.submitExportTask(task, mode, () => (completion = execute()), updateView);
+ if (mode === "immediate") {
+ await completion;
+ if (executionError !== undefined) throw executionError;
}
- return true;
}
async function exportQueryResultViaBackend(
@@ -1831,6 +2499,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
sqlExportOptions?: SqlExportOptions,
openAfterExport = false,
columnIndexes?: number[],
+ selectedMode?: ManualExportMode,
): Promise<boolean> {
if (rowIds !== undefined || columnIndexes !== undefined || context.value !== "results" || !queryResultExportRequest) {
return false;
@@ -1843,122 +2512,85 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
// backend just to stream the same rows back to a file.
if (hasCompleteLocalResult?.value) return false;
+ const sourceConnectionId = connectionId.value;
+ const sourceDatabase = database.value;
+ const sourceSql = sql.value;
+ const sourceResult = options.snapshotResult?.value;
+ const immediateBuilder = options.captureQueryResultExportRequest?.(false);
+ const queuedBuilder = options.captureQueryResultExportRequest?.(true);
+ const editorSettings = { ...useSettingsStore().editorSettings };
+ const exportId = uuid();
+ const insertTarget = format === "sql" ? sqlInsertTargetMeta() : undefined;
+ const buildOptions = {
+ exportId,
+ format,
+ includeSqlSheet,
+ exportTableName: insertTarget?.tableName,
+ exportSchema: insertTarget?.tableName ? sqlInsertTargetSchema(insertTarget) : undefined,
+ exportColumnTypes: format === "sql" || format === "xlsx" ? allColumnTypes.value?.map((type) => type ?? null) : undefined,
+ exportColumnExtras: format === "sql" ? sqlExportColumnExtras(allColumns.value) : undefined,
+ ...(format === "sql" && sqlExportOptions ? { insertMode: sqlExportOptions.insertMode } : {}),
+ };
+ const requestOptions = {
+ ...(format === "sql" ? { selectedColumns: sqlExportOptions?.selectedColumns?.map((column) => ({ ...column })) } : {}),
+ csvQuoteMode: editorSettings.csvQuoteMode,
+ nullLiteral: csvNullLiteralForMode(editorSettings.csvNullMode),
+ ...sqlExportPrimaryKeyOptions(format),
+ dateTimeFormat: editorSettings.globalDateTimeExportFormat || undefined,
+ numericColumnRightAlign: editorSettings.numericColumnRightAlign ?? true,
+ columnComments: format === "xlsx" ? buildXlsxHeaderOverrides(allColumns.value, allXlsxColumnComments.value, headerMode) : undefined,
+ headerCommentRows: format === "xlsx" && xlsxHeaderUsesCommentRows(headerMode),
+ autoFilter: format === "xlsx" ? autoFilter : undefined,
+ };
const fmt = FORMAT_META[format];
const extension = fmt?.ext ?? format;
const filterName = fmt?.label ?? format.toUpperCase();
let outputPath = exportFileName("query-result", extension);
+ const mode = openAfterExport ? "immediate" : (selectedMode ?? sqlExportOptions?.executionMode ?? (await showExportExecutionModeDialog()));
+ if (mode === null) return true;
if (isTauriRuntime()) {
if (openAfterExport) outputPath = await api.createQueryResultTempFile(extension);
else {
const path = await promptExportSavePath({
defaultFileName: outputPath,
filters: [{ name: filterName, extensions: [extension] }],
- preferredPath: useSettingsStore().editorSettings.preferredExportPath,
+ preferredPath: editorSettings.preferredExportPath,
});
if (!path) return true;
outputPath = path;
}
}
- const exportId = uuid();
- const insertTarget = format === "sql" ? sqlInsertTargetMeta() : undefined;
- const baseRequest = await queryResultExportRequest({
+ if (scopeDisposed || connectionId.value !== sourceConnectionId || database.value !== sourceDatabase || sql.value !== sourceSql || options.snapshotResult?.value !== sourceResult) {
+ toast(t("exportProgress.connectionChanged"), 5000);
+ return true;
+ }
+ const builder = mode === "queued" ? queuedBuilder : (immediateBuilder ?? queryResultExportRequest);
+ if (!builder) throw new Error("Unable to capture query result export request");
+ const build = async () => {
+ const baseRequest = await builder({ ...buildOptions, filePath: outputPath });
+ if (!baseRequest) throw new Error("Unable to build query result export request");
+ return { ...baseRequest, ...requestOptions };
+ };
+ let request: QueryResultExportRequest | undefined;
+ if (mode === "immediate") request = await build();
+ await submitBackendExport({
exportId,
- filePath: outputPath,
+ tableName: "Query Result",
format,
- includeSqlSheet,
- exportTableName: insertTarget?.tableName,
- exportSchema: insertTarget?.tableName ? sqlInsertTargetSchema(insertTarget) : undefined,
- exportColumnTypes: format === "sql" || format === "xlsx" ? allColumnTypes.value?.map((type) => type ?? null) : undefined,
- exportColumnExtras: format === "sql" ? sqlExportColumnExtras(allColumns.value) : undefined,
- ...(format === "sql" && sqlExportOptions ? { insertMode: sqlExportOptions.insertMode } : {}),
+ outputPath,
+ mode,
+ openAfterExport,
+ initialTotalRows: request?.totalRows ?? null,
+ prepare:
+ mode === "queued"
+ ? async () => {
+ request = await build();
+ }
+ : undefined,
+ start: (onProgress) => (isTauriRuntime() ? api.startQueryResultExport(request!, onProgress, true) : api.startQueryResultExport(request!, onProgress)),
+ cancel: () => api.cancelQueryResultExport(exportId, request!.executionId),
});
- const columnComments = format === "xlsx" ? buildXlsxHeaderOverrides(allColumns.value, allXlsxColumnComments.value, headerMode) : undefined;
- const headerCommentRows = format === "xlsx" && xlsxHeaderUsesCommentRows(headerMode);
- const request = baseRequest
- ? {
- ...baseRequest,
- ...(format === "sql" ? { selectedColumns: sqlExportOptions?.selectedColumns } : {}),
- csvQuoteMode: useSettingsStore().editorSettings.csvQuoteMode,
- nullLiteral: csvNullLiteralForMode(useSettingsStore().editorSettings.csvNullMode),
- ...sqlExportPrimaryKeyOptions(format),
- dateTimeFormat: useSettingsStore().editorSettings.globalDateTimeExportFormat || undefined,
- numericColumnRightAlign: useSettingsStore().editorSettings.numericColumnRightAlign ?? true,
- columnComments,
- headerCommentRows,
- autoFilter: format === "xlsx" ? autoFilter : undefined,
- }
- : undefined;
- if (!request) throw new Error("Unable to build query result export request");
-
- if (exportProgressState) {
- exportProgressState.value = {
- title: t("exportProgress.title"),
- tableName: "Query Result",
- format,
- rowsExported: 0,
- totalRows: request.totalRows ?? null,
- status: "Running",
- errorMessage: null,
- filePath: outputPath,
- startedAt: Date.now(),
- finishedAt: undefined,
- };
- }
- if (exportProgressDialog) exportProgressDialog.value = true;
- if (exportCanMinimize) exportCanMinimize.value = true;
- tracker.addTask("Query Result", format, outputPath, exportId);
- if (exportCancelHandler) {
- exportCancelHandler.value = () => api.cancelQueryResultExport(exportId, request.executionId);
- }
- tracker.registerTaskCancelHandler(exportId, () => api.cancelQueryResultExport(exportId, request.executionId));
-
- try {
- const terminalProgress = await api.startQueryResultExport(request, (progress) => {
- if (exportProgressState) {
- const adjustedTotal = progress.totalRows !== null && progress.rowsExported > progress.totalRows ? progress.rowsExported : progress.totalRows;
- exportProgressState.value = {
- ...exportProgressState.value,
- tableName: progress.tableName || "Query Result",
- rowsExported: progress.rowsExported,
- totalRows: adjustedTotal,
- status: progress.status,
- errorMessage: progress.errorMessage || null,
- finishedAt: progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled" ? Date.now() : exportProgressState.value.finishedAt,
- };
- }
- tracker.updateTableExportTask(exportId, progress);
- });
- if (terminalProgress.status === "Done") {
- notifyExportSuccess(openAfterExport ? undefined : outputPath);
- if (openAfterExport && isTauriRuntime()) {
- await api.openQueryResultTempFile(outputPath);
- }
- }
- } catch (error) {
- const errorMessage = error instanceof Error ? error.message : String(error);
- if (exportProgressState) {
- exportProgressState.value = {
- ...exportProgressState.value,
- status: "Error",
- errorMessage,
- finishedAt: Date.now(),
- };
- }
- tracker.updateTableExportTask(exportId, {
- exportId,
- tableName: "Query Result",
- rowsExported: exportProgressState?.value.rowsExported ?? 0,
- totalRows: exportProgressState?.value.totalRows ?? null,
- status: "Error",
- errorMessage,
- });
- throw error;
- } finally {
- if (exportCancelHandler) exportCancelHandler.value = null;
- tracker.unregisterTaskCancelHandler(exportId);
- if (exportCanMinimize) exportCanMinimize.value = false;
- }
return true;
}
@@ -1987,6 +2619,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
async function exportSql(target?: ExportTargetParam, columnIndexesParam?: number[]) {
const { rowIds, columnIndexes } = normalizeExportTarget(target, columnIndexesParam);
+ const isSourceCurrent = captureExportConfirmationSource();
await runExclusiveExport(async () => {
const exportId = uuid();
const exportStartedAt = performance.now();
@@ -2016,6 +2649,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const selectedSqlExportOptions = (await showSqlInsertModeDialog({
allowSplit: rowIds === undefined && columnIndexes === undefined && context.value === "table-data",
columns: sqlExportChoices(rowIds === undefined, chosenColumns),
+ showExecutionMode: isTauriRuntime(),
})) as SqlExportOptions | SqlInsertMode | null;
if (selectedSqlExportOptions === null) {
logExportStage("cancelled", { stage: "insert-mode-dialog" });
@@ -2025,6 +2659,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const insertMode = sqlExportOptions.insertMode;
logExportStage("mode-selected", { insertMode, splitMaxMb: sqlExportOptions.splitMaxMb });
try {
+ if (isTauriRuntime() && !isSourceCurrent()) throw new Error("Export result context changed");
// Step 1: table-data context — existing backend table export
logExportStage("backend-export-start");
const handledByBackend = await exportFullTableDataViaBackend("sql", rowIds, "name", true, sqlExportOptions, false, columnIndexes);
@@ -2043,6 +2678,9 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return;
}
+ if (await exportLocalSnapshot("sql", rowIds, columnIndexes, true, { sql: sqlExportOptions })) return;
+ if (await exportMemoryDataFile("sql", rowIds, columnIndexes, true, { sql: sqlExportOptions })) return;
+
// Step 3: fallback — local export (Web and edge-case scenarios)
const result = await resultToExport({ rowIds, columnIndexes }, undefined, true, false);
logExportStage(
@@ -2102,13 +2740,17 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
}
async function exportCurrentPageSql(columnIndexes?: number[]) {
+ const isSourceCurrent = captureExportConfirmationSource();
await runExclusiveExport(async () => {
const chosenColumns = columnIndexes !== undefined ? columnIndexes.map((i) => columns.value[i]).filter((c): c is string => !!c) : undefined;
- const selectedSqlExportOptions = (await showSqlInsertModeDialog({ columns: sqlExportChoices(false, chosenColumns) })) as SqlExportOptions | SqlInsertMode | null;
+ const selectedSqlExportOptions = (await showSqlInsertModeDialog({ columns: sqlExportChoices(false, chosenColumns), showExecutionMode: isTauriRuntime() })) as SqlExportOptions | SqlInsertMode | null;
if (selectedSqlExportOptions === null) return;
const sqlExportOptions: SqlExportOptions = typeof selectedSqlExportOptions === "string" ? { insertMode: selectedSqlExportOptions } : selectedSqlExportOptions;
const insertMode = sqlExportOptions.insertMode;
try {
+ if (isTauriRuntime() && !isSourceCurrent()) throw new Error("Export result context changed");
+ if (await exportLocalSnapshot("sql", undefined, columnIndexes, false, { sql: sqlExportOptions })) return;
+ if (await exportMemoryDataFile("sql", undefined, columnIndexes, false, { sql: sqlExportOptions })) return;
const result = await resultToExport({ columnIndexes }, undefined, false, false);
const exportData = sqlInsertExportData(result, sqlExportOptions.selectedColumns);
const insertTarget = sqlInsertTargetMeta();
@@ -2140,35 +2782,44 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
await copyText(sql.value);
}
- function sqlInsertExportData(
+ function sqlInsertExportData(result: Parameters<typeof captureSqlInsertExportData>[0], selectedColumns?: SqlExportColumnSelection[]) {
+ return captureSqlInsertExportData(result, selectedColumns)(result.rows);
+ }
+
+ function captureSqlInsertContext() {
+ return {
+ columns: [...columns.value],
+ sourceColumns: sourceColumns.value ? [...sourceColumns.value] : undefined,
+ columnTypes: columnTypes.value ? [...columnTypes.value] : undefined,
+ context: context.value,
+ databaseType: databaseType.value,
+ tableMeta: tableMeta.value ? (JSON.parse(JSON.stringify(tableMeta.value)) as NonNullable<typeof tableMeta.value>) : undefined,
+ };
+ }
+
+ function captureSqlInsertExportData(
result: { columns: string[]; columnTypes?: Array<string | undefined>; rows: CellValue[][]; spatialColumns?: QueryResult["spatial_columns"]; spatialValues?: QueryResult["spatial_values"] },
selectedColumns?: SqlExportColumnSelection[],
- ): {
- columns: string[];
- columnTypes?: Array<string | null | undefined>;
- columnExtras?: Array<string | null>;
- spatialColumns?: QueryResult["spatial_columns"];
- spatialValues?: QueryResult["spatial_values"];
- rows: CellValue[][];
- } {
- const matchesVisibleColumns = result.columns.length === columns.value.length && result.columns.every((column, index) => column === columns.value[index]);
- const exportColumns = context.value === "table-data" && tableMeta.value && matchesVisibleColumns ? effectiveColumns(sourceColumns.value, result.columns) : result.columns;
+ snapshot = captureSqlInsertContext(),
+ ) {
+ const matchesVisibleColumns = result.columns.length === snapshot.columns.length && result.columns.every((column, index) => column === snapshot.columns[index]);
+ const exportColumns = snapshot.context === "table-data" && snapshot.tableMeta && matchesVisibleColumns ? effectiveColumns(snapshot.sourceColumns, result.columns) : result.columns;
const columnIndexes = resolveSqlExportColumnIndexes(exportColumns, selectedColumns)
.map((index) => ({ column: exportColumns[index], index }))
.filter((item): item is { column: string; index: number } => !!item.column);
- const exportColumnTypes = matchesVisibleColumns && columnTypes.value?.length === result.columns.length ? columnTypes.value : result.columnTypes?.length === result.columns.length ? result.columnTypes : undefined;
- const metaColumns = tableMeta.value?.columns;
- const exportColumnExtras = metaColumns?.length ? exportColumns.map((column) => (column ? (findCopyColumnInfo(databaseType.value, column, tableMeta.value)?.extra ?? null) : null)) : undefined;
+ const exportColumnTypes = matchesVisibleColumns && snapshot.columnTypes?.length === result.columns.length ? snapshot.columnTypes : result.columnTypes?.length === result.columns.length ? result.columnTypes : undefined;
+ const metaColumns = snapshot.tableMeta?.columns;
+ const exportColumnExtras = metaColumns?.length ? exportColumns.map((column) => (column ? (findCopyColumnInfo(snapshot.databaseType, column, snapshot.tableMeta)?.extra ?? null) : null)) : undefined;
// SQL Server 的结果集列类型来自 TDS:rowversion 会报成 varbinary/binary,据此无法识别不可插入列;
// 表元数据(sys.columns)里才是 "timestamp"。与数据库级导出链同口径,SQL Server 的 INSERT 载荷
// 优先用表元数据类型、缺元数据时回退结果集类型(其它引擎维持结果集类型优先)。
- const metadataTypeByColumn = databaseType.value === "sqlserver" && metaColumns?.length ? new Map(metaColumns.map((meta) => [normalizeColumnName(meta.name), meta.data_type])) : undefined;
+ const metadataTypeByColumn = snapshot.databaseType === "sqlserver" && metaColumns?.length ? new Map(metaColumns.map((meta) => [normalizeColumnName(meta.name), meta.data_type])) : undefined;
const indexBySource = new Map(columnIndexes.map((item, index) => [item.index, index]));
const spatialColumns = result.spatialColumns?.flatMap((column) => {
const columnIndex = indexBySource.get(column.column_index);
return columnIndex === undefined ? [] : [{ column_index: columnIndex, srid: column.srid }];
});
- return {
+ const captured = {
columns: columnIndexes.map((item) => item.column),
columnTypes:
exportColumnTypes || metadataTypeByColumn
@@ -2180,8 +2831,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
columnExtras: exportColumnExtras?.some((extra) => !!extra) ? columnIndexes.map((item) => exportColumnExtras[item.index] ?? null) : undefined,
...(spatialColumns?.length ? { spatialColumns } : {}),
...(result.spatialValues?.length ? { spatialValues: result.spatialValues.map((row) => columnIndexes.map((item) => row[item.index] ?? null)) } : {}),
- rows: result.rows.map((row) => columnIndexes.map((item) => row[item.index] ?? null)),
};
+ return (rows: CellValue[][]) => ({ ...captured, rows: rows.map((row) => columnIndexes.map((item) => row[item.index] ?? null)) });
}
function exportFileName(fallbackBaseName: string, extension: string, options: { page?: boolean; allResults?: boolean; preferFallback?: boolean } = {}): string {
@@ -2220,7 +2871,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
exportCurrentPageXlsxWithSql,
exportAllResultsXlsx,
exportAllResultsXlsxWithSql,
- exportResultSheetsXlsx: (sheets: Array<{ sheetName: string; result: QueryResult; sql?: string }>) => exportResultSheetsXlsxResult(sheets, false),
+ exportResultSheetsXlsx: (sheets: DataGridExportSheet[]) => exportResultSheetsXlsxResult(sheets, false),
exportSql,
exportCurrentPageSql,
copySql,
diff --git a/apps/desktop/src/composables/useDataGridLargeValues.ts b/apps/desktop/src/composables/useDataGridLargeValues.ts
index 3410490d5b..b13f885121 100644
--- a/apps/desktop/src/composables/useDataGridLargeValues.ts
+++ b/apps/desktop/src/composables/useDataGridLargeValues.ts
@@ -1,11 +1,13 @@
import { computed, nextTick, onActivated, onDeactivated, ref, watch, type ComputedRef, type Ref } from "vue";
import * as api from "@/lib/backend/api";
import type { CellValue } from "@/lib/dataGrid/cellValue";
-import { buildDataGridContextFilterCondition } from "@/lib/dataGrid/dataGridSql";
+import { chunkLegacyLargeValueRequests, fetchLegacyLargeValueRequestChunk, legacyLargeValueIdentityKey as largeValueIdentityKey, legacyLargeValueRowPredicate, resolveCapturedLegacyLargeValueCells, type LegacyLargeValueContext } from "@/lib/dataGrid/legacyLargeValueExport";
import { buildTableSelectSql } from "@/lib/table/tableSelectSql";
import { shouldIncludeSyntheticRowId } from "@/lib/table/tableEditing";
import { rowIdLocatorUnsupported } from "@/lib/table/tableRowIdSupport";
import { queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
+import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
import { materializeLargeValueSnapshot, waitForLargeValueSnapshot } from "@/lib/dataGrid/largeValueSnapshot";
import type { ColumnInfo, ConnectionConfig, DatabaseType, QueryResult } from "@/types/database";
import type { DataGridRuntimeScope } from "@/lib/dataGrid/dataGridRuntime";
@@ -101,10 +103,13 @@ type LargeValueCellRequest = {
columnIndex: number;
originalBytes: number;
};
+export interface LargeValueExportCell {
+ rowId: number;
+ sourceIndex: number;
+ columnIndex: number;
+}
export function useDataGridLargeValues(options: UseDataGridLargeValuesOptions) {
- const LARGE_VALUE_FETCH_MAX_ROWS = 200;
- const LARGE_VALUE_FETCH_TARGET_BYTES = 64 * 1024 * 1024;
const pendingLargeValueHydrations = createResultScopedPendingRequests<boolean>();
const snapshotExecutionIds = new Set<string>();
let snapshotController = new AbortController();
@@ -203,15 +208,6 @@ export function useDataGridLargeValues(options: UseDataGridLargeValuesOptions) {
return options.formatCell(item.data[columnIndex], columnIndex, largeValueOriginalBytes(item, columnIndex), false);
}
- function normalizedLargeValueIdentityPart(value: CellValue): string {
- if (value === null) return "null";
- return `${typeof value}:${JSON.stringify(value)}`;
- }
-
- function largeValueIdentityKey(row: readonly CellValue[], indexes: readonly number[]): string {
- return indexes.map((index) => normalizedLargeValueIdentityPart(row[index] ?? null)).join("\u001f");
- }
-
function largeValueSourceColumnIndex(columnName: string): number {
const normalized = columnName.toLocaleLowerCase();
return options.resultSourceColumns.value.findIndex((column) => column.toLocaleLowerCase() === normalized);
@@ -462,96 +458,60 @@ export function useDataGridLargeValues(options: UseDataGridLargeValuesOptions) {
onDeactivated(pauseVisibleLargeValuePreviewHydration);
options.runtimeScope.addCleanup(pauseVisibleLargeValuePreviewHydration);
- function chunkLargeValueRequests(requests: LargeValueCellRequest[]): LargeValueCellRequest[][] {
- // PostgreSQL full-value SQL uses SELECT *, so this column's exact byte size
- // cannot bound other large columns in the same row. Keep the one-row batches
- // used before bytea markers started reporting exact sizes.
- const maxRows = options.databaseType.value === "postgres" ? 1 : LARGE_VALUE_FETCH_MAX_ROWS;
- const chunks: LargeValueCellRequest[][] = [];
- let chunk: LargeValueCellRequest[] = [];
- let bytes = 0;
- for (const request of requests) {
- if (chunk.length > 0 && (chunk.length >= maxRows || bytes + request.originalBytes > LARGE_VALUE_FETCH_TARGET_BYTES)) {
- chunks.push(chunk);
- chunk = [];
- bytes = 0;
- }
- chunk.push(request);
- bytes += request.originalBytes;
- }
- if (chunk.length > 0) chunks.push(chunk);
- return chunks;
- }
-
- async function largeValueRowPredicate(sourceIndex: number, primaryKeyIndexes: number[]): Promise<string> {
- const originalRow = options.result.value.rows[sourceIndex];
- if (!originalRow) throw new Error(options.translate("grid.largeValueRowUnavailable"));
- const tableMeta = options.tableMeta.value!;
- const conditions = await Promise.all(
- tableMeta.primaryKeys.map((columnName, index) =>
- buildDataGridContextFilterCondition({
- databaseType: options.databaseType.value,
- identifierQuote: options.connectionIdentifierQuote(options.connectionId.value),
- columnName,
- columnInfo: tableMeta.columns.find((column) => column.name.toLocaleLowerCase() === columnName.toLocaleLowerCase()),
- mode: "equals",
- value: originalRow[primaryKeyIndexes[index]!] ?? null,
- }),
- ),
- );
- if (conditions.some((condition) => !condition)) throw new Error(options.translate("grid.largeValueRowUnavailable"));
- return conditions.map((condition) => `(${condition})`).join(" AND ");
- }
-
- async function fetchLargeValueRequestChunk(columnIndex: number, requests: LargeValueCellRequest[], primaryKeyIndexes: number[], resolved: ResolvedLargeValueCells) {
- const tableMeta = options.tableMeta.value!;
- const sourceColumn = options.resultSourceColumns.value[columnIndex];
- if (!sourceColumn) throw new Error(options.translate("grid.largeValueColumnUnavailable"));
- const predicates = await Promise.all(requests.map((request) => largeValueRowPredicate(request.sourceIndex, primaryKeyIndexes)));
- const selectedColumns = [...new Set([...tableMeta.primaryKeys, sourceColumn])];
- const sql = await buildTableSelectSql({
+ function captureLegacyContext(sourceIndexes: number[]): LegacyLargeValueContext {
+ const connectionId = options.connectionId.value;
+ const connection = connectionId ? options.getConnectionConfig(connectionId) : undefined;
+ const tableMeta = options.tableMeta.value;
+ return {
databaseType: options.databaseType.value,
- serverVersion: options.getConnectionConfig(options.connectionId.value!)?.database_info?.productVersion,
- identifierQuote: options.connectionIdentifierQuote(options.connectionId.value),
- database: tableMeta.database,
- schema: tableMeta.schema,
- tableName: tableMeta.tableName,
- tableType: tableMeta.tableType,
- catalog: tableMeta.catalog,
- columns: selectedColumns,
+ connectionId,
+ executionDatabase: options.executionDatabase.value,
+ tableMeta: tableMeta ? JSON.parse(JSON.stringify(tableMeta)) : undefined,
+ sourceColumns: [...options.resultSourceColumns.value],
+ rows: sourceIndexes.reduce<CellValue[][]>((rows, index) => {
+ const row = options.result.value.rows[index];
+ if (row) rows[index] = JSON.parse(JSON.stringify(row));
+ return rows;
+ }, []),
+ identifierQuote: options.connectionIdentifierQuote(connectionId),
+ serverVersion: connection?.database_info?.productVersion,
includeDatabaseName: options.includeDatabaseName.value,
- primaryKeys: tableMeta.primaryKeys,
- whereInput: predicates.map((predicate) => `(${predicate})`).join(" OR "),
- limit: requests.length,
- offset: 0,
- includeRowId: shouldIncludeSyntheticRowId(options.databaseType.value, tableMeta.primaryKeys, tableMeta.tableType) && !(options.connectionId.value ? rowIdLocatorUnsupported(options.connectionId.value) : false),
- });
- const connection = options.connectionId.value ? options.getConnectionConfig(options.connectionId.value!) : undefined;
- const results = await api.executeMulti(options.connectionId.value!, options.executionDatabase.value, sql, undefined, options.uuid(), {
- maxRows: requests.length,
- fetchSize: requests.length,
+ includeRowId: !!tableMeta && shouldIncludeSyntheticRowId(options.databaseType.value, tableMeta.primaryKeys, tableMeta.tableType) && !(connectionId ? rowIdLocatorUnsupported(connectionId) : false),
timeoutSecs: queryTimeoutSecsForConnection(connection, options.globalQueryTimeoutSecs.value),
- });
- const result = results[0];
- if (!result || result.execution_error) {
- throw new Error(result?.error ? options.translateBackendError(result.error) : String(result?.rows?.[0]?.[0] ?? options.translate("grid.largeValueLoadFailed")));
- }
- const resultColumnIndexes = selectedColumns.map((column) => {
- const normalized = column.toLocaleLowerCase();
- return result.columns.findIndex((resultColumn) => resultColumn.toLocaleLowerCase() === normalized);
- });
- if (resultColumnIndexes.some((index) => index < 0)) throw new Error(options.translate("grid.largeValueColumnUnavailable"));
- const resultPrimaryKeyIndexes = resultColumnIndexes.slice(0, tableMeta.primaryKeys.length);
- const resultValueIndex = resultColumnIndexes[selectedColumns.indexOf(sourceColumn)];
- const valuesByIdentity = new Map(result.rows.map((row) => [largeValueIdentityKey(row, resultPrimaryKeyIndexes), row[resultValueIndex!] ?? null]));
- for (const request of requests) {
- const originalRow = options.result.value.rows[request.sourceIndex];
- const identity = originalRow ? largeValueIdentityKey(originalRow, primaryKeyIndexes) : "";
- if (!valuesByIdentity.has(identity)) throw new Error(options.translate("grid.largeValueRowUnavailable"));
- const rowValues = resolved.get(request.rowId) ?? new Map<number, CellValue>();
- rowValues.set(columnIndex, valuesByIdentity.get(identity) ?? null);
- resolved.set(request.rowId, rowValues);
+ };
+ }
+
+ function chunkLargeValueRequests(requests: LargeValueCellRequest[], databaseType = options.databaseType.value) {
+ return chunkLegacyLargeValueRequests(requests, databaseType);
+ }
+
+ function largeValueRowPredicate(sourceIndex: number, primaryKeyIndexes: number[], context = captureLegacyContext([sourceIndex])) {
+ return legacyLargeValueRowPredicate(context, sourceIndex, primaryKeyIndexes, options);
+ }
+
+ function fetchLargeValueRequestChunk(columnIndex: number, requests: LargeValueCellRequest[], primaryKeyIndexes: number[], resolved: ResolvedLargeValueCells, context = captureLegacyContext(requests.map((request) => request.sourceIndex))) {
+ return fetchLegacyLargeValueRequestChunk(context, columnIndex, requests, primaryKeyIndexes, resolved, options);
+ }
+
+ function captureSourceValues(cells: LargeValueExportCell[]) {
+ const metadata = largeValueCellMap(options.result.value);
+ const requestsByColumn = new Map<number, LargeValueCellRequest[]>();
+ for (const cell of cells) {
+ const value = metadata.get(largeValueCellKey(cell.sourceIndex, cell.columnIndex));
+ if (!value || value.value_ref) continue;
+ const requests = requestsByColumn.get(cell.columnIndex) ?? [];
+ if (!requests.some((request) => request.rowId === cell.rowId)) requests.push({ ...cell, originalBytes: value.original_bytes });
+ requestsByColumn.set(cell.columnIndex, requests);
}
+ const context = captureLegacyContext(cells.map((cell) => cell.sourceIndex));
+ const config = context.connectionId ? options.getConnectionConfig(context.connectionId) : undefined;
+ const fingerprint = config ? connectionConfigFingerprint(config) : undefined;
+ const requests = [...requestsByColumn.values()].flat();
+ return (signal: AbortSignal) =>
+ resolveCapturedLegacyLargeValueCells(context, requests, signal, options, () => {
+ const current = context.connectionId ? options.getConnectionConfig(context.connectionId) : undefined;
+ if (!current || connectionConfigFingerprint(current) !== fingerprint) throw new SnapshotCompletionError("failed", "Export connection changed");
+ });
}
async function resolveLargeValueCells(rowIds: number[], columnIndexes: number[]): Promise<ResolvedLargeValueCells> {
@@ -823,6 +783,7 @@ export function useDataGridLargeValues(options: UseDataGridLargeValuesOptions) {
}
return {
+ captureSourceValues,
snapshotReference,
captureSnapshotDownloadTarget,
isSnapshotDownloadTargetCurrent,
diff --git a/apps/desktop/src/composables/useExportTracker.ts b/apps/desktop/src/composables/useExportTracker.ts
index d54dfb91ac..9040d0dfcd 100644
--- a/apps/desktop/src/composables/useExportTracker.ts
+++ b/apps/desktop/src/composables/useExportTracker.ts
@@ -4,10 +4,11 @@ import { isTerminalTransferProgress } from "@/lib/backend/transferProgress";
import { uuid } from "@/lib/common/utils";
import { formatQueryDuration } from "@/lib/format/duration";
import { autoRevealExportedPathIfConfigured } from "@/lib/export/exportPath";
+import { releaseManualExport, submitManualExport, type ManualExportMode } from "@/lib/export/manualExportQueue";
import { acceptOraclePackageTransferApproval, acceptOraclePackageTransferPreflight, acceptOracleRoutineDeploymentOperation, type OracleRoutineDeployment } from "@/lib/schema/oracleRoutineDeploy";
export type BackgroundTaskKind = "table-export" | "database-export" | "data-dictionary" | "sql-file" | "data-transfer" | "data-generation" | "multi-db-execution" | "schema-diff" | "data-compare";
-export type BackgroundTaskStatus = "Running" | "Writing" | "Cancelling" | "Done" | "Error" | "Cancelled";
+export type BackgroundTaskStatus = "Queued" | "Unknown" | "Running" | "Writing" | "Cancelling" | "Done" | "Error" | "Cancelled";
export type DatabaseExportSource = "manual" | "scheduled";
export interface DataTransferFailure {
@@ -401,10 +402,43 @@ function findActiveOverlappingTransfer(request: api.TransferRequest): string[] {
export function useExportTracker() {
const tasks = computed(() => Array.from(taskMap.values()));
- const activeCount = computed(() => tasks.value.filter((t) => t.status === "Running" || t.status === "Writing" || t.status === "Cancelling").length);
+ const activeCount = computed(() => tasks.value.filter((t) => t.status === "Queued" || t.status === "Unknown" || t.status === "Running" || t.status === "Writing" || t.status === "Cancelling").length);
const hasActive = computed(() => activeCount.value > 0);
+ function submitExportTask(task: ExportTask, mode: ManualExportMode, run: () => Promise<"settled" | "unknown">, onStateChange?: (task: ExportTask) => void) {
+ let handle: ReturnType<typeof submitManualExport>;
+ const cancelQueued = () => {
+ handle.cancelQueued();
+ };
+ handle = submitManualExport({
+ id: task.exportId,
+ mode,
+ run,
+ onStateChange(state, error) {
+ if (state === "queued") {
+ task.status = "Queued";
+ task.startedAt = undefined;
+ taskCancelHandlers.set(task.exportId, cancelQueued);
+ } else if (state === "running") {
+ if (taskCancelHandlers.get(task.exportId) === cancelQueued) taskCancelHandlers.delete(task.exportId);
+ task.status = "Running";
+ task.startedAt = Date.now();
+ } else if (state === "cancelled") {
+ task.status = "Cancelled";
+ task.finishedAt = Date.now();
+ taskCancelHandlers.delete(task.exportId);
+ } else if (state === "unknown") {
+ task.status = "Unknown";
+ task.finishedAt = undefined;
+ if (error !== undefined) task.errorMessage = error instanceof Error ? error.message : String(error);
+ }
+ onStateChange?.(task);
+ },
+ });
+ return handle;
+ }
+
function addTask(tableName: string, format: string, filePath: string, exportId?: string): ExportTask {
const id = exportId ?? uuid();
const task = reactive<ExportTask>({
@@ -847,6 +881,7 @@ export function useExportTracker() {
function removeTask(exportId: string) {
const task = taskMap.get(exportId);
+ if (task?.status === "Unknown") releaseManualExport(exportId);
if (task && (task.status === "Done" || task.status === "Error" || task.status === "Cancelled")) cleanupFinishedTask(task);
taskMap.delete(exportId);
taskCancelHandlers.delete(exportId);
@@ -877,6 +912,7 @@ export function useExportTracker() {
async function cancelTask(exportId: string) {
const task = taskMap.get(exportId);
if (task?.canCancel === false) return;
+ if (task && (task.kind === "table-export" || task.kind === "database-export") && (task.status === "Done" || task.status === "Error" || task.status === "Cancelled" || task.status === "Unknown" || task.status === "Cancelling")) return;
try {
const customHandler = taskCancelHandlers.get(exportId);
if (customHandler) {
@@ -900,6 +936,7 @@ export function useExportTracker() {
tasks,
activeCount,
hasActive,
+ submitExportTask,
addTask,
addDatabaseExportTask,
addDataDictionaryTask,
diff --git a/apps/desktop/src/composables/useSidebarTreeExportRuntime.ts b/apps/desktop/src/composables/useSidebarTreeExportRuntime.ts
index 528faa6fe2..aa6a72ff3a 100644
--- a/apps/desktop/src/composables/useSidebarTreeExportRuntime.ts
+++ b/apps/desktop/src/composables/useSidebarTreeExportRuntime.ts
@@ -38,6 +38,10 @@ import type { CsvQuoteMode } from "@/lib/export/csvQuoteMode";
import { csvNullLiteralForMode } from "@/lib/export/csvNullMode";
import type { SqlInsertDialect } from "@/lib/export/sqlInsertMode";
import { uuid } from "@/lib/common/utils";
+import { showExportExecutionModeDialog } from "@/lib/export/exportExecutionMode";
+import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
type StructureCopyFormat = "tsv" | "markdown";
@@ -65,6 +69,12 @@ interface SidebarTableExportTarget {
csvQuoteMode: CsvQuoteMode;
/** 导出 CSV 时 NULL 的字面量;空串表示关闭(旧行为)。 */
nullLiteral: string;
+ primaryKeyMode: api.TableExportRequest["primaryKeyMode"];
+ omitDatabaseQualifier: boolean;
+ dateTimeFormat?: string;
+ connectionFingerprint: string;
+ connectionType: string;
+ queryTimeoutSecs?: number;
fileNameBase?: string;
}
@@ -99,6 +109,13 @@ interface ExportTableDataOptions {
outputDirectory?: string;
suppressDoneToast?: boolean;
insertDialect?: SqlInsertDialect;
+ operation?: {
+ outputPath: string;
+ task?: ExportTask;
+ check: () => void;
+ read: <T>(request: () => Promise<T>, cleanup?: boolean) => Promise<T>;
+ setActive: (task: ExportTask, cancel: (() => Promise<void>) | undefined) => void;
+ };
}
function joinExportFilePath(directory: string, fileName: string): string {
@@ -109,7 +126,8 @@ function joinExportFilePath(directory: string, fileName: string): string {
export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOptions) {
const { t } = useI18n();
const { toast } = useToast();
- const { addTask: addExportTask, updateTableExportTask } = useExportTracker();
+ const tracker = useExportTracker();
+ const { addTask: addExportTask, updateTableExportTask } = tracker;
const { activeNode, connectionStore, settingsStore } = options;
async function saveFileContent(content: string, defaultFileName: string, filterName: string, filterExt: string) {
@@ -375,15 +393,24 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
return resolveExportOutputPath(target.fileNameBase ?? target.tableName, format, outputDirectory);
}
- async function exportDataLegacyForTarget(target: SidebarTableExportTarget, outputDirectory?: string, suppressDoneToast = false) {
+ async function exportDataLegacyForTarget(target: SidebarTableExportTarget, outputDirectory?: string, suppressDoneToast = false, operation?: ExportTableDataOptions["operation"]) {
const { connectionId, database } = target;
const config = connectionStore.getConfig(connectionId);
- if (!config) return false;
+ if (!config && !operation) return false;
+ let task: ExportTask | undefined;
try {
+ operation?.check();
await connectionStore.ensureConnected(connectionId);
- const queryColumns = config.db_type === "neo4j" ? (await api.getColumns(connectionId, database, target.metadataSchema, target.tableName, target.catalog)).map((column) => column.name) : undefined;
- const useAgentCursor = config.db_type === "cassandra";
+ operation?.check();
+ if (operation) {
+ task = operation.task ?? addExportTask(target.tableName, "json", operation.outputPath);
+ operation.setActive(task, undefined);
+ }
+ const read: NonNullable<ExportTableDataOptions["operation"]>["read"] = operation?.read ?? (<T>(request: () => Promise<T>) => request());
+ const connectionType = operation ? target.connectionType : config!.db_type;
+ const queryColumns = connectionType === "neo4j" ? (await read(() => api.getColumns(connectionId, database, target.metadataSchema, target.tableName, target.catalog))).map((column) => column.name) : undefined;
+ const useAgentCursor = connectionType === "cassandra";
const clientSessionId = useAgentCursor ? `table-export:${uuid()}` : undefined;
const result = await fetchTableDataForExport({
databaseType: target.databaseType,
@@ -393,21 +420,41 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
tableType: target.tableType,
columns: queryColumns,
useAgentCursor,
- executePage: (sql, cursorOptions) => (cursorOptions ? api.executeQuery(connectionId, database, sql, undefined, undefined, { ...cursorOptions, clientSessionId, catalog: target.catalog, timeoutSecs: config.query_timeout_secs }) : api.executeQuery(connectionId, database, sql)),
+ executePage: async (sql, cursorOptions) => {
+ const result = await read(() =>
+ cursorOptions ? api.executeQuery(connectionId, database, sql, undefined, undefined, { ...cursorOptions, clientSessionId, catalog: target.catalog, timeoutSecs: operation ? target.queryTimeoutSecs : config!.query_timeout_secs }) : api.executeQuery(connectionId, database, sql),
+ );
+ if (operation) {
+ if (result.execution_error) throw new SnapshotCompletionError(result.error?.operationOutcome === "not_started" ? "failed" : "unknown", translateBackendError(t, result.error ?? String(result.rows[0]?.[0] ?? "Query failed")));
+ if (result.large_value_cells?.length || result.truncated) throw new SnapshotCompletionError("failed", "Incomplete table export result");
+ }
+ return result;
+ },
closeCursor: useAgentCursor
? async (sessionId) => {
try {
- if (sessionId) await api.closeQuerySession(connectionId, database, sessionId, clientSessionId, target.catalog);
+ if (sessionId) await read(() => api.closeQuerySession(connectionId, database, sessionId, clientSessionId, target.catalog), true);
} finally {
- await api.closeClientConnectionSession(connectionId, database, clientSessionId!, target.catalog);
+ await read(() => (operation ? api.closeClientConnectionSession(connectionId, database, clientSessionId!, target.catalog, true) : api.closeClientConnectionSession(connectionId, database, clientSessionId!, target.catalog)), true);
}
}
: undefined,
});
- const outputPath = await resolveTableExportOutputPath(target, "json", outputDirectory);
+ operation?.check();
+ const outputPath = operation?.outputPath ?? (await resolveTableExportOutputPath(target, "json", outputDirectory));
if (!outputPath) return false;
- await api.exportQueryResultJson(outputPath, result.columns, result.rows);
+ if (task && operation) {
+ task.canCancel = false;
+ operation.setActive(task, undefined);
+ }
+ await read(() => api.exportQueryResultJson(outputPath, result.columns, result.rows));
+ if (task) {
+ task.status = "Done";
+ task.rowsExported = result.rows.length;
+ task.totalRows = result.rows.length;
+ task.finishedAt = Date.now();
+ }
if (!suppressDoneToast) {
notifyExportComplete({
filePath: outputPath,
@@ -418,6 +465,14 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
}
return true;
} catch (error: any) {
+ if (operation) {
+ if (task) {
+ task.status = error instanceof SnapshotCompletionError && error.status === "unknown" ? "Unknown" : error instanceof SnapshotCompletionError && error.status === "cancelled" ? "Cancelled" : "Error";
+ task.errorMessage = error?.message || String(error);
+ task.finishedAt = task.status === "Unknown" ? undefined : Date.now();
+ }
+ throw error;
+ }
toast(t("grid.exportFailed", { message: translateBackendError(t, error) }), 5000);
return false;
}
@@ -432,6 +487,7 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
const app = createApp(XlsxHeaderDialog, {
open: true,
showHeaderOptions: hasComments,
+ showExecutionMode: isTauriRuntime(),
onConfirm: (exportOptions: XlsxExportOptions) => {
resolve(exportOptions);
app.unmount();
@@ -472,6 +528,12 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
rowLimit: editorSettings.exportRowLimitEnabled ? editorSettings.exportRowLimit : null,
csvQuoteMode: editorSettings.csvQuoteMode,
nullLiteral: csvNullLiteralForMode(editorSettings.csvNullMode),
+ primaryKeyMode: editorSettings.dataGridExtractorOptions.sql.primaryKeyMode,
+ omitDatabaseQualifier: dropsSchemaQualifier(effectiveDatabaseTypeForConnection(config), editorSettings.generateSqlIncludeDatabaseName, node.catalog),
+ dateTimeFormat: editorSettings.globalDateTimeExportFormat || undefined,
+ connectionFingerprint: connectionConfigFingerprint(config),
+ connectionType: config.db_type,
+ queryTimeoutSecs: config.query_timeout_secs,
};
}
@@ -484,18 +546,22 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
}
async function exportTableData(target: SidebarTableExportTarget, format: "csv" | "xlsx" | "sql", exportOptions: ExportTableDataOptions = {}) {
- const { columnInfos, headerMode = "name", autoFilter = true, outputDirectory, suppressDoneToast = false, insertDialect = "source" } = exportOptions;
+ const { columnInfos, headerMode = "name", autoFilter = true, outputDirectory, suppressDoneToast = false, insertDialect = "source", operation } = exportOptions;
const { connectionId, database } = target;
let task: ExportTask | null = null;
try {
- const outputPath = await resolveTableExportOutputPath(target, format, outputDirectory);
+ const outputPath = operation?.outputPath ?? (await resolveTableExportOutputPath(target, format, outputDirectory));
if (!outputPath) return false;
+ operation?.check();
await connectionStore.ensureConnected(connectionId);
- task = addExportTask(target.tableName, format, outputPath);
+ operation?.check();
+ task = operation?.task ?? addExportTask(target.tableName, format, outputPath);
const currentTask = task;
- const exportColumnInfos = columnInfos ?? (target.loadColumnMetadata ? await api.getColumns(connectionId, database, target.metadataSchema, target.tableName, target.catalog) : undefined);
+ const read = operation?.read ?? (<T>(request: () => Promise<T>) => request());
+ operation?.setActive(currentTask, undefined);
+ const exportColumnInfos = columnInfos ?? (target.loadColumnMetadata ? await read(() => api.getColumns(connectionId, database, target.metadataSchema, target.tableName, target.catalog)) : undefined);
const queryColumns = exportColumnInfos?.map((column) => column.name);
const primaryKeys = exportColumnInfos?.filter((column) => column.is_primary_key).map((column) => column.name);
if (target.databaseType === "victoriametrics") {
@@ -504,25 +570,18 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
schema: target.schema,
tableName: target.tableName,
tableType: target.tableType,
- executePage: (sql) => api.executeQuery(connectionId, database, sql),
+ executePage: (sql) => read(() => api.executeQuery(connectionId, database, sql)),
});
+ operation?.check();
+ if (operation && (result.execution_error || result.large_value_cells?.length || result.truncated)) throw new SnapshotCompletionError(result.execution_error && result.error?.operationOutcome !== "not_started" ? "unknown" : "failed", "Incomplete table export result");
+ if (operation) currentTask.canCancel = false;
+ operation?.setActive(currentTask, undefined);
if (format === "csv") {
- await api.exportQueryResultCsv(outputPath, result.columns, result.rows, target.csvQuoteMode, target.nullLiteral);
+ await read(() => api.exportQueryResultCsv(outputPath, result.columns, result.rows, target.csvQuoteMode, target.nullLiteral));
} else {
const comments = result.columns.map((name) => exportColumnInfos?.find((column) => column.name.toLocaleLowerCase() === name.toLocaleLowerCase())?.comment);
const headerOverrides = buildXlsxHeaderOverrides(result.columns, comments, headerMode);
- await api.exportQueryResultXlsx(
- outputPath,
- target.tableName,
- result.columns,
- result.column_types ?? result.columns.map(() => ""),
- headerOverrides,
- result.rows,
- undefined,
- autoFilter,
- settingsStore.editorSettings.globalDateTimeExportFormat || undefined,
- xlsxHeaderUsesCommentRows(headerMode),
- );
+ await read(() => api.exportQueryResultXlsx(outputPath, target.tableName, result.columns, result.column_types ?? result.columns.map(() => ""), headerOverrides, result.rows, undefined, autoFilter, target.dateTimeFormat, xlsxHeaderUsesCommentRows(headerMode)));
}
currentTask.status = "Done";
currentTask.rowsExported = result.rows.length;
@@ -557,7 +616,7 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
...(format === "sql"
? {
insertDialect,
- omitDatabaseQualifier: dropsSchemaQualifier(target.databaseType, settingsStore.editorSettings.generateSqlIncludeDatabaseName, target.catalog),
+ omitDatabaseQualifier: target.omitDatabaseQualifier,
}
: {}),
csvQuoteMode: target.csvQuoteMode,
@@ -567,13 +626,19 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
headerCommentRows: format === "xlsx" ? xlsxHeaderUsesCommentRows(headerMode) : undefined,
autoFilter: format === "xlsx" ? autoFilter : undefined,
primaryKeys,
- primaryKeyMode: settingsStore.editorSettings.dataGridExtractorOptions.sql.primaryKeyMode,
+ primaryKeyMode: target.primaryKeyMode,
batchSize: target.batchSize,
skipCount: format === "sql",
rowLimit: target.rowLimit,
};
- await api.startTableExport(request, (progress) => {
+ operation?.check();
+ let terminalSeen = false;
+ let terminalProgress: api.TableExportProgress | undefined;
+ operation?.setActive(currentTask, () => api.cancelTableExport(currentTask.exportId));
+ const onProgress = (progress: api.TableExportProgress) => {
+ terminalSeen ||= progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled";
+ if (progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled") terminalProgress = progress;
updateTableExportTask(currentTask.exportId, progress);
if (progress.status === "Done") {
if (!suppressDoneToast) {
@@ -585,9 +650,26 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
});
}
} else if (progress.status === "Error") toast(t("grid.exportFailed", { message: translateBackendError(t, progress.errorMessage || "") }), 5000);
+ };
+ await (operation ? api.startTableExport(request, onProgress, true) : api.startTableExport(request, onProgress)).catch((error) => {
+ if (error instanceof SnapshotCompletionError && error.status === "failed") throw error;
+ if (operation && !terminalSeen) throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ if (operation && terminalProgress?.status === "Done") return terminalProgress;
+ if (operation && terminalProgress?.status === "Cancelled") throw new SnapshotCompletionError("cancelled", terminalProgress.errorMessage || "Export cancelled");
+ throw error;
});
+ if (operation && !terminalSeen) throw new SnapshotCompletionError("unknown", "Export completion was not confirmed");
+ if (operation && terminalProgress) updateTableExportTask(currentTask.exportId, terminalProgress);
return true;
} catch (error: any) {
+ if (operation) {
+ if (task) {
+ task.status = error instanceof SnapshotCompletionError && error.status === "unknown" ? "Unknown" : error instanceof SnapshotCompletionError && error.status === "cancelled" ? "Cancelled" : "Error";
+ task.errorMessage = error?.message || String(error);
+ task.finishedAt = task.status === "Unknown" ? undefined : Date.now();
+ }
+ throw error;
+ }
if (task) {
task.status = "Error";
task.errorMessage = error?.message || String(error);
@@ -603,7 +685,208 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
return pickTableExportDirectory();
}
+ async function submitTableExports(targets: SidebarTableExportTarget[], format: "csv" | "xlsx" | "sql" | "json", outputDirectory: string | undefined, mode: ManualExportMode, optionsForTarget: (target: SidebarTableExportTarget) => ExportTableDataOptions) {
+ const capturedOptions = targets.map((target) => {
+ const options = optionsForTarget(target);
+ return { ...options, columnInfos: options.columnInfos?.map((column) => ({ ...column })) };
+ });
+ const paths: string[] = [];
+ for (const target of targets) {
+ const path = await resolveTableExportOutputPath(target, format, outputDirectory);
+ if (!path) return;
+ paths.push(path);
+ }
+ const selectedIds = currentTableExportTargets()
+ .map((target) => target.nodeId)
+ .join("\n");
+ if (selectedIds !== targets.map((target) => target.nodeId).join("\n")) {
+ toast(t("exportProgress.connectionChanged"), 5000);
+ return;
+ }
+ const task = addExportTask(targets.map((target) => target.tableName).join(", "), format, targets.length === 1 ? paths[0]! : outputDirectory!);
+ let complete!: () => void;
+ const completion = new Promise<void>((resolve) => {
+ complete = resolve;
+ });
+ tracker.submitExportTask(
+ task,
+ mode,
+ async () => {
+ const controller = new AbortController();
+ const active: { task?: ExportTask; cancel?: () => Promise<void> } = {};
+ const cancel = async () => {
+ controller.abort();
+ task.status = "Cancelling";
+ if (active.task) active.task.status = "Cancelling";
+ await active.cancel?.();
+ };
+ tracker.registerTaskCancelHandler(task.exportId, cancel);
+ let unknown = false;
+ let unknownMessage: string | undefined;
+ let exported = 0;
+ let failed = false;
+ try {
+ for (let index = 0; index < targets.length; index++) {
+ if (controller.signal.aborted) break;
+ const target = targets[index]!;
+ const check = () => {
+ if (unknown) throw new SnapshotCompletionError("unknown", unknownMessage ?? "Export operation completion was not confirmed");
+ if (controller.signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ const config = connectionStore.getConfig(target.connectionId);
+ if (!config || connectionConfigFingerprint(config) !== target.connectionFingerprint) throw new SnapshotCompletionError("failed", t("exportProgress.connectionChanged"));
+ };
+ const read = async <T>(request: () => Promise<T>, cleanup = false): Promise<T> => {
+ if (!cleanup) check();
+ let result: T;
+ try {
+ result = await request();
+ } catch (error) {
+ unknown = true;
+ unknownMessage ??= error instanceof Error ? error.message : String(error);
+ throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ }
+ if (!cleanup && active.task?.canCancel !== false) check();
+ return result;
+ };
+ try {
+ const operation: NonNullable<ExportTableDataOptions["operation"]> = {
+ outputPath: paths[index]!,
+ task: targets.length === 1 ? task : undefined,
+ check,
+ read,
+ setActive: (child, cancelChild) => {
+ if (active.task && active.task !== task) tracker.unregisterTaskCancelHandler(active.task.exportId);
+ active.task = child;
+ active.cancel = cancelChild;
+ task.canCancel = child.canCancel !== false;
+ if (child !== task) tracker.registerTaskCancelHandler(child.exportId, cancel);
+ },
+ };
+ const succeeded = format === "json" ? await exportDataLegacyForTarget(target, outputDirectory, targets.length > 1, operation) : await exportTableData(target, format, { ...capturedOptions[index], suppressDoneToast: targets.length > 1, operation });
+ if (succeeded && active.task?.status === "Done") exported++;
+ if (active.task?.status === "Error") {
+ failed = true;
+ task.errorMessage = active.task.errorMessage;
+ }
+ if (active.task?.status === "Cancelled") controller.abort();
+ } catch (error) {
+ unknown ||= error instanceof SnapshotCompletionError && error.status === "unknown";
+ task.errorMessage = error instanceof Error ? error.message : String(error);
+ if (unknown) {
+ task.status = "Unknown";
+ return "unknown";
+ }
+ if (error instanceof SnapshotCompletionError && error.status === "cancelled") break;
+ failed = true;
+ toast(t("grid.exportFailed", { message: translateBackendError(t, error) }), 5000);
+ }
+ if (active.task && active.task !== task) tracker.unregisterTaskCancelHandler(active.task.exportId);
+ active.task = undefined;
+ active.cancel = undefined;
+ task.canCancel = true;
+ }
+ task.status = exported === targets.length ? "Done" : controller.signal.aborted ? "Cancelled" : failed ? "Error" : "Done";
+ task.finishedAt = Date.now();
+ if (targets.length > 1 && exported > 0) toast(t("contextMenu.exportDataMultipleSuccess", { count: exported }));
+ return "settled";
+ } finally {
+ if (!unknown) {
+ tracker.unregisterTaskCancelHandler(task.exportId);
+ if (active.task && active.task !== task) tracker.unregisterTaskCancelHandler(active.task.exportId);
+ }
+ task.canCancel = false;
+ if (unknown && active.task) active.task.canCancel = false;
+ }
+ },
+ (current) => {
+ if (current.status === "Done" || current.status === "Error" || current.status === "Cancelled" || current.status === "Unknown") complete();
+ },
+ );
+ if (mode === "immediate") await completion;
+ }
+
+ async function exportQueuedMongoCollection(outputFormat: "csv" | "ndjson" | "bson" | "bsonGzip") {
+ const node = activeNode.value;
+ if (node.type !== "mongo-collection" || !node.connectionId || !node.database) return;
+ const connectionId = node.connectionId;
+ const database = node.database;
+ const collection = node.label;
+ const config = connectionStore.getConfig(connectionId);
+ const fingerprint = config ? connectionConfigFingerprint(config) : undefined;
+ const preferredPath = settingsStore.editorSettings.preferredExportPath;
+ const format = outputFormat === "bsonGzip" ? "bson" : outputFormat;
+ const extension = outputFormat === "bsonGzip" ? "bson.gz" : outputFormat;
+ const mode = await showExportExecutionModeDialog();
+ if (mode === null) return;
+ const outputPath = await promptExportSavePath({ defaultFileName: `${collection}.${extension}`, filters: [{ name: exportFilterName(extension), extensions: [outputFormat === "bsonGzip" ? "gz" : extension] }], preferredPath });
+ if (!outputPath) return;
+ const task = addExportTask(collection, format, outputPath);
+ task.canCancel = true;
+ let complete!: () => void;
+ const completion = new Promise<void>((resolve) => {
+ complete = resolve;
+ });
+ tracker.submitExportTask(
+ task,
+ mode,
+ async () => {
+ let started = false;
+ let cancelled = false;
+ tracker.registerTaskCancelHandler(task.exportId, async () => {
+ cancelled = true;
+ task.status = "Cancelling";
+ if (started) await api.cancelMongodbExport(task.exportId);
+ });
+ const check = () => {
+ const current = connectionStore.getConfig(connectionId);
+ if (!current || connectionConfigFingerprint(current) !== fingerprint) throw new Error(t("exportProgress.connectionChanged"));
+ };
+ try {
+ check();
+ await connectionStore.ensureConnected(connectionId);
+ check();
+ if (cancelled) {
+ task.status = "Cancelled";
+ task.finishedAt = Date.now();
+ return "settled";
+ }
+ started = true;
+ const summary = await api.exportMongodbQuery(
+ { exportId: task.exportId, connectionId, database, collection, format, includeHeader: true, gzip: outputFormat === "bsonGzip", filePath: outputPath },
+ (progress) => {
+ task.rowsExported = progress.documentsRead;
+ task.totalRows = progress.totalDocuments ?? null;
+ if (task.status !== "Cancelling") task.status = "Writing";
+ task.errorMessage = progress.errorMessage ?? null;
+ },
+ true,
+ );
+ task.status = "Done";
+ task.rowsExported = summary.documentsExported;
+ task.finishedAt = Date.now();
+ notifyExportComplete({ filePath: outputPath, message: t("grid.exported"), openFolderLabel: t("exportProgress.openFolder"), toast });
+ return "settled";
+ } catch (error) {
+ task.errorMessage = error instanceof Error ? error.message : String(error);
+ const status = error instanceof SnapshotCompletionError ? error.status : started ? "unknown" : "failed";
+ task.status = status === "unknown" ? "Unknown" : status === "cancelled" ? "Cancelled" : "Error";
+ task.finishedAt = status === "unknown" ? undefined : Date.now();
+ if (status !== "cancelled") toast(t("grid.exportFailed", { message: translateBackendError(t, error) }), 5000);
+ return status === "unknown" ? "unknown" : "settled";
+ } finally {
+ if (task.status !== "Unknown") tracker.unregisterTaskCancelHandler(task.exportId);
+ task.canCancel = false;
+ }
+ },
+ (current) => {
+ if (current.status === "Done" || current.status === "Error" || current.status === "Cancelled" || current.status === "Unknown") complete();
+ },
+ );
+ if (mode === "immediate") await completion;
+ }
+
async function exportMongoCollection(outputFormat: "csv" | "ndjson" | "bson" | "bsonGzip") {
+ if (isTauriRuntime()) return exportQueuedMongoCollection(outputFormat);
const node = activeNode.value;
if (node.type !== "mongo-collection" || !node.connectionId || !node.database) return;
const format: api.MongoExportFormat = outputFormat === "bsonGzip" ? "bson" : outputFormat;
@@ -658,9 +941,14 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
const targets = currentTableExportTargets();
if (!targets.length) return;
+ const mode = isTauriRuntime() ? await showExportExecutionModeDialog() : undefined;
+ if (mode === null) return;
+
const outputDirectory = await resolveMultiTableExportDirectory(targets.length);
if (outputDirectory === null) return;
+ if (mode) return submitTableExports(targets, format, outputDirectory, mode, () => ({ insertDialect }));
+
if (format === "json") {
let exported = 0;
for (const target of targets) {
@@ -697,10 +985,14 @@ export function useSidebarTreeExportRuntime(options: SidebarTreeExportRuntimeOpt
const xlsxOptions = await showSidebarTreeXlsxHeaderDialog(hasComments);
if (xlsxOptions === null) return;
+ const mode = isTauriRuntime() ? (xlsxOptions.executionMode ?? (await showExportExecutionModeDialog())) : undefined;
+ if (mode === null) return;
const outputDirectory = await resolveMultiTableExportDirectory(targets.length);
if (outputDirectory === null) return;
+ if (mode) return submitTableExports(targets, "xlsx", outputDirectory, mode, (target) => ({ columnInfos: columnInfosByTarget.get(tableExportTargetCacheKey(target)), headerMode: xlsxOptions.headerMode, autoFilter: xlsxOptions.autoFilter }));
+
let exported = 0;
for (const target of targets) {
if (
diff --git a/apps/desktop/src/i18n/locales/az.ts b/apps/desktop/src/i18n/locales/az.ts
index af989843d9..e3dc229da9 100644
--- a/apps/desktop/src/i18n/locales/az.ts
+++ b/apps/desktop/src/i18n/locales/az.ts
@@ -2706,6 +2706,14 @@ export default withEnglishFallback({
cut: "Kəs",
},
exportProgress: {
+ connectionChanged: "İxrac bağlantısı dəyişdi. Yeni ixrac başlayın.",
+ transactionUnavailable: "İxrac tranzaksiyası artıq mövcud deyil. Yeni ixrac başlayın.",
+ executionMode: "İcra rejimi",
+ immediate: "Dərhal ixrac et",
+ queue: "İxracı növbəyə al",
+ queued: "Növbədədir",
+ unknown: "İxrac statusu bilinmir; növbə dayandırılıb",
+ executionModeHint: "Dərhal ixraclar paralel işləyə bilər; növbəyə alınmış ixraclar bir-bir icra olunur.",
streamingUnsupported: "Bu sorğu üçün axınla ixrac dəstəklənmir. Sorğunu sadələşdirin və ya dəstəklənən drayverdən istifadə edin.",
agentSessionMissing: "Axınla ixrac üçün nəticə dəsti sessiyası tələb olunur, lakin bu drayver session_id qaytarmadı.",
title: "Cədvəl məlumatları ixrac edilir",
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index fcd6fc5bbc..caa1ced8ab 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -3672,6 +3672,14 @@ export default {
cut: "Cut",
},
exportProgress: {
+ connectionChanged: "The export connection changed. Start a new export.",
+ transactionUnavailable: "The export transaction is no longer available. Start a new export.",
+ executionMode: "Execution",
+ immediate: "Export now",
+ queue: "Queue export",
+ queued: "Queued",
+ unknown: "Export status unknown; the queue is blocked",
+ executionModeHint: "Immediate exports may run in parallel; queued exports run one at a time.",
streamingUnsupported: "Streaming export is unsupported for this query. Simplify it or use a supported driver.",
agentSessionMissing: "Streaming export needs a result-set session, but this driver returned no session_id.",
title: "Exporting Table Data",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index 6e3e4d4e3d..97f9bfdc1a 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -3436,6 +3436,14 @@ export default withEnglishFallback({
pageProbeDescription: "Esta página muestra como máximo {count} filas; se lee como máximo 1 fila adicional para determinar si hay una página siguiente.",
},
exportProgress: {
+ connectionChanged: "La conexión de exportación ha cambiado. Inicie una nueva exportación.",
+ transactionUnavailable: "La transacción de exportación ya no está disponible. Inicie una nueva exportación.",
+ executionMode: "Ejecución",
+ immediate: "Exportar ahora",
+ queue: "Poner en cola",
+ queued: "En cola",
+ unknown: "Estado de exportación desconocido; la cola está bloqueada",
+ executionModeHint: "Las exportaciones inmediatas pueden ejecutarse en paralelo; las de la cola se ejecutan de una en una.",
streamingUnsupported: "La exportación en streaming no es compatible con esta consulta. Simplifíquela o use un controlador compatible.",
agentSessionMissing: "La exportación en streaming requiere una sesión de conjunto de resultados, pero este controlador no devolvió session_id.",
title: "Exportando datos de la tabla",
diff --git a/apps/desktop/src/i18n/locales/id.ts b/apps/desktop/src/i18n/locales/id.ts
index f9929915ad..3f546e9b4c 100644
--- a/apps/desktop/src/i18n/locales/id.ts
+++ b/apps/desktop/src/i18n/locales/id.ts
@@ -3031,6 +3031,14 @@ export default withEnglishFallback({
cut: "Potong",
},
exportProgress: {
+ connectionChanged: "Koneksi ekspor berubah. Mulai ekspor baru.",
+ transactionUnavailable: "Transaksi ekspor tidak lagi tersedia. Mulai ekspor baru.",
+ executionMode: "Mode eksekusi",
+ immediate: "Ekspor sekarang",
+ queue: "Antrekan ekspor",
+ queued: "Dalam antrean",
+ unknown: "Status ekspor tidak diketahui; antrean terblokir",
+ executionModeHint: "Ekspor langsung dapat berjalan paralel; ekspor dalam antrean berjalan satu per satu.",
streamingUnsupported: "Ekspor streaming tidak didukung untuk kueri ini. Sederhanakan kueri atau gunakan driver yang didukung.",
agentSessionMissing: "Ekspor streaming memerlukan sesi result-set, tetapi driver ini tidak mengembalikan session_id.",
title: "Mengekspor Data Tabel",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 27d6641866..247ac89835 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -3309,6 +3309,14 @@ export default withEnglishFallback({
pageProbeDescription: "Questa pagina mostra al massimo {count} righe; viene letta al massimo 1 riga aggiuntiva per determinare se esiste una pagina successiva.",
},
exportProgress: {
+ connectionChanged: "La connessione di esportazione è cambiata. Avvia una nuova esportazione.",
+ transactionUnavailable: "La transazione di esportazione non è più disponibile. Avvia una nuova esportazione.",
+ executionMode: "Esecuzione",
+ immediate: "Esporta ora",
+ queue: "Metti in coda",
+ queued: "In coda",
+ unknown: "Stato dell'esportazione sconosciuto; la coda è bloccata",
+ executionModeHint: "Le esportazioni immediate possono essere parallele; quelle in coda vengono eseguite una alla volta.",
streamingUnsupported: "L'esportazione in streaming non è supportata per questa query. Semplificala o usa un driver supportato.",
agentSessionMissing: "L'esportazione in streaming richiede una sessione del set di risultati, ma questo driver non ha restituito session_id.",
title: "Esportazione Dati Tabella",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 2a3cfd4866..3f428baf72 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -3333,6 +3333,14 @@ export default withEnglishFallback({
pageProbeDescription: "このページには最大 {count} 行を表示し、次のページがあるかどうかを判断するために最大 1 行を追加で読み取ります。",
},
exportProgress: {
+ connectionChanged: "エクスポート先の接続が変更されました。エクスポートをやり直してください。",
+ transactionUnavailable: "エクスポートに使用するトランザクションは無効です。エクスポートをやり直してください。",
+ executionMode: "実行方法",
+ immediate: "今すぐエクスポート",
+ queue: "キューに追加",
+ queued: "待機中",
+ unknown: "エクスポート状態を確認できないため、キューを停止しています",
+ executionModeHint: "即時エクスポートは並列実行でき、キュー内のエクスポートは順番に実行されます。",
streamingUnsupported: "このクエリはストリーミングエクスポートに対応していません。クエリを簡略化するか、対応しているドライバーを使用してください。",
agentSessionMissing: "ストリーミングエクスポートには結果セットのセッションが必要ですが、このドライバーは session_id を返しませんでした。",
title: "テーブルデータをエクスポート中",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index 80d450aef2..446e932fdd 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -3263,6 +3263,14 @@ export default withEnglishFallback({
pageProbeDescription: "이 페이지에는 최대 {count}행이 표시되며, 다음 페이지가 있는지 판단하기 위해 최대 1행을 추가로 읽습니다.",
},
exportProgress: {
+ connectionChanged: "내보내기 연결이 변경되었습니다. 새로 내보내세요.",
+ transactionUnavailable: "내보내기 트랜잭션을 더 이상 사용할 수 없습니다. 새로 내보내세요.",
+ executionMode: "실행 방식",
+ immediate: "지금 내보내기",
+ queue: "대기열에 추가",
+ queued: "대기 중",
+ unknown: "내보내기 상태를 확인할 수 없어 대기열이 중지되었습니다",
+ executionModeHint: "즉시 내보내기는 병렬로 실행될 수 있으며, 대기열의 내보내기는 하나씩 실행됩니다.",
streamingUnsupported: "이 쿼리는 스트리밍 내보내기를 지원하지 않습니다. 쿼리를 단순화하거나 지원되는 드라이버를 사용하세요.",
agentSessionMissing: "스트리밍 내보내기에는 결과 집합 세션이 필요하지, 이 드라이버는 session_id를 반환하지 않았습니다.",
title: "테이블 데이터 내보내는 중",
diff --git a/apps/desktop/src/i18n/locales/pl.ts b/apps/desktop/src/i18n/locales/pl.ts
index 3e4eadd1a1..8a9e0b8bf0 100644
--- a/apps/desktop/src/i18n/locales/pl.ts
+++ b/apps/desktop/src/i18n/locales/pl.ts
@@ -3103,6 +3103,14 @@ export default withEnglishFallback({
cut: "Wytnij",
},
exportProgress: {
+ connectionChanged: "Połączenie eksportu uległo zmianie. Rozpocznij nowy eksport.",
+ transactionUnavailable: "Transakcja eksportu nie jest już dostępna. Rozpocznij nowy eksport.",
+ executionMode: "Tryb wykonania",
+ immediate: "Eksportuj teraz",
+ queue: "Dodaj eksport do kolejki",
+ queued: "W kolejce",
+ unknown: "Stan eksportu nieznany; kolejka jest wstrzymana",
+ executionModeHint: "Eksporty natychmiastowe mogą działać równolegle; eksporty w kolejce są wykonywane pojedynczo.",
streamingUnsupported: "Eksport strumieniowy nie jest obsługiwany dla tego zapytania. Uprość je lub użyj zgodnego sterownika.",
agentSessionMissing: "Eksport strumieniowy wymaga sesji zbioru wyników, ale sterownik nie zwrócił session_id.",
title: "Aktualizacja zabezpieczeń danych",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 16c4219e6a..2a42c45e1a 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -3309,6 +3309,14 @@ export default withEnglishFallback({
pageProbeDescription: "Esta página exibe no máximo {count} linhas, com leitura adicional de no máximo 1 linha para determinar se há uma próxima página.",
},
exportProgress: {
+ connectionChanged: "A conexão de exportação mudou. Inicie uma nova exportação.",
+ transactionUnavailable: "A transação de exportação não está mais disponível. Inicie uma nova exportação.",
+ executionMode: "Execução",
+ immediate: "Exportar agora",
+ queue: "Adicionar à fila",
+ queued: "Na fila",
+ unknown: "Status da exportação desconhecido; a fila está bloqueada",
+ executionModeHint: "As exportações imediatas podem ser paralelas; as da fila são executadas uma por vez.",
streamingUnsupported: "A exportação em streaming não é compatível com esta consulta. Simplifique-a ou use um driver compatível.",
agentSessionMissing: "A exportação em streaming requer uma sessão de conjunto de resultados, mas este driver não retornou session_id.",
title: "Exportando Dados da Tabela",
diff --git a/apps/desktop/src/i18n/locales/ru.ts b/apps/desktop/src/i18n/locales/ru.ts
index 747d00d094..9c7abbad9b 100644
--- a/apps/desktop/src/i18n/locales/ru.ts
+++ b/apps/desktop/src/i18n/locales/ru.ts
@@ -3393,6 +3393,14 @@ export default withEnglishFallback({
pageProbeDescription: "На этой странице отображается не более {count} строк; дополнительно считывается не более 1 строки, чтобы определить, есть ли следующая страница.",
},
exportProgress: {
+ connectionChanged: "Подключение для экспорта изменилось. Начните новый экспорт.",
+ transactionUnavailable: "Транзакция для экспорта больше недоступна. Начните новый экспорт.",
+ executionMode: "Режим выполнения",
+ immediate: "Экспортировать сейчас",
+ queue: "Добавить в очередь",
+ queued: "В очереди",
+ unknown: "Статус экспорта неизвестен; очередь заблокирована",
+ executionModeHint: "Немедленный экспорт может выполняться параллельно; задания в очереди выполняются по одному.",
streamingUnsupported: "Потоковый экспорт не поддерживается для этого запроса. Упростите его или используйте поддерживаемый драйвер.",
agentSessionMissing: "Для потокового экспорта требуется сессия набора результатов, но этот драйвер не вернул session_id.",
title: "Экспорт данных таблицы",
diff --git a/apps/desktop/src/i18n/locales/th.ts b/apps/desktop/src/i18n/locales/th.ts
index a6992d74c0..216fbbeefc 100644
--- a/apps/desktop/src/i18n/locales/th.ts
+++ b/apps/desktop/src/i18n/locales/th.ts
@@ -3579,6 +3579,14 @@ export default withEnglishFallback({
copyExtractorHeaderTwoRows: "ชื่อและคำอธิบาย (แบ่งเป็นสองบรรทัด)",
},
exportProgress: {
+ connectionChanged: "การเชื่อมต่อสำหรับส่งออกเปลี่ยนไป โปรดเริ่มส่งออกใหม่",
+ transactionUnavailable: "ไม่สามารถใช้ธุรกรรมสำหรับส่งออกได้แล้ว โปรดเริ่มส่งออกใหม่",
+ executionMode: "วิธีดำเนินการ",
+ immediate: "ส่งออกทันที",
+ queue: "เพิ่มลงคิว",
+ queued: "อยู่ในคิว",
+ unknown: "ไม่สามารถยืนยันสถานะการส่งออกได้ คิวจึงหยุดรอ",
+ executionModeHint: "การส่งออกทันทีอาจทำงานพร้อมกัน ส่วนรายการในคิวจะทำงานทีละรายการ",
streamingUnsupported: "ไม่รองรับการส่งออกแบบ Streaming สำหรับ Query นี้ ทำให้เรียบง่ายขึ้นหรือใช้ Driver ที่รองรับ",
agentSessionMissing: "การส่งออกแบบ Streaming ต้องใช้เซสชันชุดผลลัพธ์ แต่ Driver นี้ไม่ส่ง session_id กลับมา",
title: "กำลังส่งออกข้อมูลตาราง",
diff --git a/apps/desktop/src/i18n/locales/tr.ts b/apps/desktop/src/i18n/locales/tr.ts
index 7989a3dbe2..e957884ff3 100644
--- a/apps/desktop/src/i18n/locales/tr.ts
+++ b/apps/desktop/src/i18n/locales/tr.ts
@@ -2698,6 +2698,14 @@ export default withEnglishFallback({
cut: "Kes",
},
exportProgress: {
+ connectionChanged: "Dışa aktarma bağlantısı değişti. Yeni bir dışa aktarma başlatın.",
+ transactionUnavailable: "Dışa aktarma işlemi artık kullanılamıyor. Yeni bir dışa aktarma başlatın.",
+ executionMode: "Yürütme modu",
+ immediate: "Şimdi dışa aktar",
+ queue: "Dışa aktarmayı kuyruğa al",
+ queued: "Kuyruğa alındı",
+ unknown: "Dışa aktarma durumu bilinmiyor; kuyruk engellendi",
+ executionModeHint: "Anında dışa aktarmalar paralel çalışabilir; kuyruktaki dışa aktarmalar tek tek çalışır.",
streamingUnsupported: "Bu sorgu için akış tabanlı dışa aktarma desteklenmiyor. Sorguyu basitleştirin veya desteklenen bir sürücü kullanın.",
agentSessionMissing: "Akış tabanlı dışa aktarma bir sonuç kümesi oturumu gerektirir, ancak bu sürücü session_id döndürmedi.",
title: "Tablo Verisi Dışa Aktarılıyor",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 4207c9ea90..53444d8d67 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -3602,6 +3602,14 @@ export default withEnglishFallback({
victoriaMetricsTruncatedHint: "结果超过加载上限,仅加载前 {count} 行。右下角每页行数只调整已加载数据的分页显示;请缩短查询时间范围或增加筛选条件以获取完整结果。",
},
exportProgress: {
+ connectionChanged: "导出连接已变化,请重新发起导出。",
+ transactionUnavailable: "导出事务已失效,请重新发起导出。",
+ executionMode: "执行方式",
+ immediate: "立即导出",
+ queue: "排队导出",
+ queued: "排队中",
+ unknown: "无法确认导出状态,队列已停止推进",
+ executionModeHint: "立即导出可并行;排队导出依次执行。",
streamingUnsupported: "当前查询暂不支持流式导出,请简化查询或使用受支持的驱动。",
agentSessionMissing: "流式导出需要结果集会话,但当前驱动未返回 session_id。",
title: "导出表数据",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 44befcae3e..c30519029a 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -3310,6 +3310,14 @@ export default withEnglishFallback({
tableDataPreviewLoadFailed: "載入完整文字失敗:{message}",
},
exportProgress: {
+ connectionChanged: "匯出連線已變更,請重新發起匯出。",
+ transactionUnavailable: "匯出交易已失效,請重新發起匯出。",
+ executionMode: "執行方式",
+ immediate: "立即匯出",
+ queue: "排隊匯出",
+ queued: "排隊中",
+ unknown: "無法確認匯出狀態,佇列已停止推進",
+ executionModeHint: "立即匯出可並行;排隊匯出依序執行。",
streamingUnsupported: "目前查詢暫不支援串流匯出,請簡化查詢或使用支援的驅動程式。",
agentSessionMissing: "串流匯出需要結果集工作階段,但目前驅動程式未回傳 session_id。",
title: "匯出資料表資料",
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/largeValueSnapshot.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/largeValueSnapshot.spec.ts
index a1656ef4b0..3fcef60b2d 100644
--- a/apps/desktop/src/lib/__tests__/dataGrid/largeValueSnapshot.spec.ts
+++ b/apps/desktop/src/lib/__tests__/dataGrid/largeValueSnapshot.spec.ts
@@ -5,9 +5,75 @@ import { materializeLargeValueSnapshot, materializeSnapshotResultRows, readLarge
const request = { connectionId: "ob", database: "APP", clientSessionId: "tab-original", valueRef: "original-ref" };
const response = (data: string, next_offset: number, eof = false) => ({ status: "ok", data, next_offset, eof, value_kind: "text" });
-beforeEach(() => mocks.readLargeValueChunk.mockReset());
+beforeEach(() => {
+ mocks.readLargeValueChunk.mockReset();
+});
describe("original-result LOB snapshot consumption", () => {
+ it("preserves the existing immediate local-abort behavior by default", async () => {
+ let finish!: (chunk: ReturnType<typeof response>) => void;
+ mocks.readLargeValueChunk.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const controller = new AbortController();
+ const consume = vi.fn();
+ const reading = readLargeValueSnapshot(request, () => true, consume, controller.signal);
+ controller.abort(new Error("cancelled locally"));
+ await expect(reading).rejects.toThrow("cancelled locally");
+ finish(response("x", 1, true));
+ expect(consume).not.toHaveBeenCalled();
+ });
+
+ it("retains the native read until it settles before releasing an aborted export", async () => {
+ let finish!: (chunk: ReturnType<typeof response>) => void;
+ mocks.readLargeValueChunk.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const controller = new AbortController();
+ const consume = vi.fn();
+ let settled = false;
+ const reading = readLargeValueSnapshot(request, () => true, consume, controller.signal, mocks.readLargeValueChunk, true).catch((error) => {
+ settled = true;
+ return error;
+ });
+ controller.abort(new Error("cancelled locally"));
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ finish(response("x", 1));
+ expect(await reading).toEqual(expect.objectContaining({ message: "cancelled locally" }));
+ expect(consume).not.toHaveBeenCalled();
+ expect(mocks.readLargeValueChunk).toHaveBeenCalledOnce();
+ });
+
+ it("retains native completion while materializing an aborted result", async () => {
+ let finish!: (chunk: ReturnType<typeof response>) => void;
+ mocks.readLargeValueChunk.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const controller = new AbortController();
+ const result = { columns: ["PAYLOAD"], rows: [["preview"]], affected_rows: 0, execution_time_ms: 0, large_value_cells: [{ row_index: 0, column_index: 0, original_bytes: 1, value_ref: "original-ref" }], large_value_context: { connectionId: "ob", database: "APP" } };
+ let settled = false;
+ const reading = materializeSnapshotResultRows(result, () => true, controller.signal, "export-execution", { waitForNative: true }).catch((error) => {
+ settled = true;
+ return error;
+ });
+ controller.abort(new Error("cancelled result"));
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ finish(response("x", 1, true));
+ expect(await reading).toEqual(expect.objectContaining({ message: "cancelled result" }));
+ expect(result.rows).toEqual([["preview"]]);
+ });
+
it("preserves every binary byte and prefixes the assembled value exactly once", async () => {
const hex = Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0")).join("");
mocks.readLargeValueChunk.mockResolvedValueOnce({ ...response(hex.slice(0, 200), 100), value_kind: "binary" }).mockResolvedValueOnce({ ...response(hex.slice(200), 256, true), value_kind: "binary" });
diff --git a/apps/desktop/src/lib/backend/__tests__/snapshotCompletion.spec.ts b/apps/desktop/src/lib/backend/__tests__/snapshotCompletion.spec.ts
new file mode 100644
index 0000000000..6b684122cc
--- /dev/null
+++ b/apps/desktop/src/lib/backend/__tests__/snapshotCompletion.spec.ts
@@ -0,0 +1,132 @@
+import { beforeEach, expect, it, vi } from "vitest";
+import { exportDatabaseSql, exportMongodbQuery, exportSnapshotResult, readLargeValueChunk, startTableExport, startQueryResultExport } from "../tauri";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
+
+const mocks = vi.hoisted(() => ({ invoke: vi.fn(), listen: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: mocks.listen }));
+
+const context = { connectionId: "original", database: "APP", valueRef: "captured" };
+const request = { context, format: "json" as const, columns: ["C"], rows: [["preview"]], cells: [{ rowIndex: 0, columnIndex: 0, valueRef: "captured" }] };
+
+beforeEach(() => {
+ mocks.invoke.mockReset();
+ mocks.listen.mockReset();
+});
+
+it.each([startTableExport, startQueryResultExport, exportDatabaseSql])("reports only pre-invoke listener failure as confirmed not-started", async (start) => {
+ mocks.listen.mockRejectedValueOnce(new Error("listener unavailable"));
+ await expect(start({ exportId: "not-started" } as never, vi.fn(), true)).rejects.toEqual(new SnapshotCompletionError("failed", "listener unavailable"));
+ expect(mocks.invoke).not.toHaveBeenCalled();
+ mocks.listen.mockResolvedValueOnce(vi.fn());
+ mocks.invoke.mockRejectedValueOnce(new Error("invoke reply lost"));
+ await expect(start({ exportId: "unknown" } as never, vi.fn(), true)).rejects.not.toBeInstanceOf(SnapshotCompletionError);
+});
+
+it("preserves default export adapter error wrapping when listener setup fails", async () => {
+ mocks.listen.mockRejectedValueOnce(new Error("listener unavailable"));
+ await expect(startTableExport({ exportId: "old" } as never, vi.fn())).rejects.not.toBeInstanceOf(SnapshotCompletionError);
+ expect(mocks.invoke).not.toHaveBeenCalled();
+});
+
+it("keeps native cleanup-unknown progress from becoming a releasable table terminal", async () => {
+ let receive!: (event: { payload: unknown }) => void;
+ const unlisten = vi.fn();
+ mocks.listen.mockImplementationOnce(async (_name, callback) => {
+ receive = callback;
+ return unlisten;
+ });
+ mocks.invoke.mockResolvedValueOnce(undefined);
+ const progress = vi.fn();
+ const pending = startTableExport({ exportId: "cleanup-unknown" } as never, progress, true);
+ await Promise.resolve();
+ await Promise.resolve();
+ receive({ payload: { exportId: "cleanup-unknown", tableName: "T", rowsExported: 0, totalRows: null, status: "Unknown", errorMessage: "session close unknown" } });
+ await expect(pending).rejects.toThrow("session close unknown");
+ expect(progress).toHaveBeenCalledWith(expect.objectContaining({ status: "Unknown" }));
+ expect(unlisten).toHaveBeenCalledOnce();
+});
+
+it("keeps default native payloads and the existing post-invoke abort behavior", async () => {
+ const controller = new AbortController();
+ mocks.invoke.mockImplementationOnce(async () => {
+ controller.abort(new Error("local abort"));
+ });
+ await expect(exportSnapshotResult(request, "original.json", controller.signal)).rejects.toThrow("local abort");
+ expect(mocks.invoke).toHaveBeenLastCalledWith("export_snapshot_result", { request, filePath: "original.json" });
+ mocks.invoke.mockResolvedValueOnce({ data: "old chunk" });
+ await expect(readLargeValueChunk(context)).resolves.toEqual({ data: "old chunk" });
+ expect(mocks.invoke).toHaveBeenLastCalledWith("read_large_value_chunk", { request: context });
+});
+
+it("preserves confirmed persisted success when cancellation arrives late", async () => {
+ const controller = new AbortController();
+ mocks.invoke.mockImplementationOnce(async () => {
+ controller.abort(new Error("late abort"));
+ return { status: "succeeded", value: null };
+ });
+ await expect(exportSnapshotResult(request, "original.json", controller.signal, true)).resolves.toBeUndefined();
+ expect(mocks.invoke).toHaveBeenLastCalledWith("export_snapshot_result", { request, filePath: "original.json", reportOutcome: true });
+});
+
+it.each(["failed", "cancelled", "unknown"] as const)("preserves the native %s evidence for reads and writes", async (status) => {
+ mocks.invoke.mockResolvedValue({ status, message: "original failure" });
+ for (const operation of [() => readLargeValueChunk(context, true), () => exportSnapshotResult(request, "original.json", undefined, true)]) {
+ await expect(operation()).rejects.toEqual(new SnapshotCompletionError(status, "original failure"));
+ }
+});
+
+it("does not upgrade IPC rejection or an invalid envelope into completion evidence", async () => {
+ const error = new Error("IPC lost");
+ mocks.invoke.mockRejectedValueOnce(error);
+ await expect(readLargeValueChunk(context, true)).rejects.toBe(error);
+ mocks.invoke.mockResolvedValueOnce({ status: "failed" });
+ await expect(exportSnapshotResult(request, "original.json", undefined, true)).rejects.not.toBeInstanceOf(SnapshotCompletionError);
+});
+
+it.each(["failed", "cancelled", "unknown"] as const)("unwraps Mongo %s only after the native invocation returns", async (status) => {
+ let receive!: (event: { payload: unknown }) => void;
+ mocks.listen.mockImplementationOnce(async (_name, callback) => {
+ receive = callback;
+ return vi.fn();
+ });
+ let complete!: (value: unknown) => void;
+ mocks.invoke.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ complete = resolve;
+ }),
+ );
+ const request = { exportId: "mongo" } as never;
+ const pending = exportMongodbQuery(request, vi.fn(), true);
+ await vi.waitFor(() => expect(mocks.invoke).toHaveBeenCalledOnce());
+ expect(mocks.invoke).toHaveBeenCalledWith("export_mongodb_query", { request, reportOutcome: true });
+ let settled = false;
+ void pending.then(
+ () => {
+ settled = true;
+ },
+ () => {
+ settled = true;
+ },
+ );
+ receive({ payload: { exportId: "mongo", status: "cancelled" } });
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ complete({ status, message: "actual completion" });
+ await expect(pending).rejects.toEqual(new SnapshotCompletionError(status, "actual completion"));
+});
+
+it("keeps the default Mongo wire and distinguishes listener failure from invoke uncertainty", async () => {
+ const request = { exportId: "mongo" } as never;
+ const summary = { documentsExported: 2 };
+ mocks.listen.mockResolvedValue(vi.fn());
+ mocks.invoke.mockResolvedValueOnce(summary);
+ await expect(exportMongodbQuery(request, vi.fn())).resolves.toEqual(summary);
+ expect(mocks.invoke).toHaveBeenLastCalledWith("export_mongodb_query", { request });
+ mocks.listen.mockRejectedValueOnce(new Error("listen failed"));
+ await expect(exportMongodbQuery(request, vi.fn(), true)).rejects.toBeInstanceOf(SnapshotCompletionError);
+ const error = new Error("IPC failed");
+ mocks.invoke.mockRejectedValueOnce(error);
+ await expect(exportMongodbQuery(request, vi.fn(), true)).rejects.toBe(error);
+});
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index 5fe2e1dd9e..ed9ee9404d 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -2,6 +2,7 @@ import type { StarRocksAlterOptions } from "@/lib/table/starrocksAlterOptions";
import type { CreateTableDialectOptions } from "@/lib/table/starrocksPhysicalOptions";
import { invoke as tauriInvoke } from "@tauri-apps/api/core";
import { Channel } from "@tauri-apps/api/core";
+import { SnapshotCompletionError, unwrapSnapshotCompletion } from "@/lib/export/snapshotCompletion";
import type { MongoDumpFormat, MongoDumpSourceInput, MongoDumpCatalog, MongoRestoreSourcePreview, MongoDatabaseDumpRequest, MongoDatabaseRestoreRequest, MongoDatabaseDumpProgress } from "./mongodbDumpTypes";
import type { MongoRestoreUpload, MongoSourceReadOptions } from "./mongodbDumpTypes";
import type { DamengDumpKind, DamengDumpRequest, DamengDumpProgress } from "./damengDumpTypes";
@@ -2221,7 +2222,11 @@ export async function cancelConditionalUpdate(executionId: string, options?: { c
return invoke("cancel_conditional_update", { executionId, ...options });
}
-export async function readLargeValueChunk(request: import("./http").LargeValueRequest): Promise<import("./http").LargeValueChunk> {
+export async function readLargeValueChunk(request: import("./http").LargeValueRequest, reportOutcome = false): Promise<import("./http").LargeValueChunk> {
+ if (reportOutcome) {
+ const { unwrapSnapshotCompletion } = await import("@/lib/export/snapshotCompletion");
+ return unwrapSnapshotCompletion(await invoke("read_large_value_chunk", { request, reportOutcome: true }));
+ }
return invoke("read_large_value_chunk", { request });
}
@@ -2236,8 +2241,13 @@ export async function downloadLargeValue(request: import("./http").LargeValueReq
signal?.throwIfAborted();
}
-export async function exportSnapshotResult(request: import("./http").SnapshotExportRequest, filePath: string, signal?: AbortSignal): Promise<void> {
+export async function exportSnapshotResult(request: import("./http").SnapshotExportRequest, filePath: string, signal?: AbortSignal, reportOutcome = false): Promise<void> {
signal?.throwIfAborted();
+ if (reportOutcome) {
+ const { unwrapSnapshotCompletion } = await import("@/lib/export/snapshotCompletion");
+ unwrapSnapshotCompletion(await invoke("export_snapshot_result", { request, filePath, reportOutcome: true }));
+ return;
+ }
await invoke("export_snapshot_result", { request, filePath });
signal?.throwIfAborted();
}
@@ -2253,12 +2263,13 @@ export async function closeQuerySession(connectionId: string, database: string,
});
}
-export async function closeClientConnectionSession(connectionId: string, database: string, clientSessionId: string, catalog?: string): Promise<boolean> {
+export async function closeClientConnectionSession(connectionId: string, database: string, clientSessionId: string, catalog?: string, reportCompletion = false): Promise<boolean> {
return invoke("close_client_connection_session", {
connectionId,
database,
clientSessionId,
catalog,
+ ...(reportCompletion ? { reportCompletion: true } : {}),
});
}
@@ -6517,22 +6528,32 @@ export async function releaseMongodbImportSource(_sourceRef: string): Promise<bo
return false;
}
-export async function exportMongodbQuery(request: MongoExportRequest, onProgress: (progress: MongoExportProgress) => void): Promise<MongoExportSummary> {
- const unlisten: UnlistenFn = await listen<MongoExportProgress>("mongo-export-progress", (event) => {
- if (event.payload.exportId === request.exportId) {
- onProgress(event.payload);
- if (event.payload.status === "done" || event.payload.status === "error" || event.payload.status === "cancelled") {
- unlisten();
+export async function exportMongodbQuery(request: MongoExportRequest, onProgress: (progress: MongoExportProgress) => void, reportOutcome = false): Promise<MongoExportSummary> {
+ let unlisten: UnlistenFn;
+ try {
+ unlisten = await listen<MongoExportProgress>("mongo-export-progress", (event) => {
+ if (event.payload.exportId === request.exportId) {
+ onProgress(event.payload);
+ if (event.payload.status === "done" || event.payload.status === "error" || event.payload.status === "cancelled") {
+ unlisten();
+ }
}
- }
- });
+ });
+ } catch (error) {
+ if (reportOutcome) throw new SnapshotCompletionError("failed", String(error));
+ throw error;
+ }
try {
+ if (reportOutcome) {
+ return unwrapSnapshotCompletion<MongoExportSummary>(await invoke("export_mongodb_query", { request, reportOutcome: true }));
+ }
const summary = await invoke<MongoExportSummary>("export_mongodb_query", { request });
- unlisten();
return summary;
} catch (e) {
- unlisten();
+ if (reportOutcome) throw e;
throw e instanceof BackendErrorException ? e : new BackendErrorException(e);
+ } finally {
+ unlisten();
}
}
@@ -6578,7 +6599,7 @@ export interface ExportProgress {
totalObjects: number;
rowsExported: number;
totalRows: number | null;
- status: "Running" | "Done" | "Error" | "Cancelled";
+ status: "Running" | "Done" | "Error" | "Cancelled" | "Unknown";
error: string | null;
/** True while listing schema / prefetching metadata before objects are written. */
preparing?: boolean;
@@ -6589,7 +6610,7 @@ export interface ExportProgress {
}
// --- Table Export ---
-export type TableExportStatus = "Running" | "Writing" | "Done" | "Error" | "Cancelled";
+export type TableExportStatus = "Running" | "Writing" | "Done" | "Error" | "Cancelled" | "Unknown";
export interface TableExportRequest {
exportId: string;
@@ -6705,8 +6726,9 @@ export interface QueryResultExportRequest {
primaryKeys?: string[];
}
-export async function startTableExport(request: TableExportRequest, onProgress: (progress: TableExportProgress) => void): Promise<TableExportProgress> {
+export async function startTableExport(request: TableExportRequest, onProgress: (progress: TableExportProgress) => void, reportCompletion = false): Promise<TableExportProgress> {
let unlisten: UnlistenFn | undefined;
+ let invoked = false;
let settled = false;
let resolveTerminal: (progress: TableExportProgress) => void = () => {};
let rejectTerminal: (error: unknown) => void = () => {};
@@ -6727,7 +6749,9 @@ export async function startTableExport(request: TableExportRequest, onProgress:
unlisten = await listen<TableExportProgress>("table-export-progress", (event) => {
if (event.payload.exportId !== request.exportId) return;
onProgress(event.payload);
- if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
+ if (event.payload.status === "Unknown") {
+ finish(() => rejectTerminal(new SnapshotCompletionError("unknown", event.payload.errorMessage || "Export cleanup completion was not confirmed")));
+ } else if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
if (event.payload.status === "Error") {
finish(() => rejectTerminal(new BackendErrorException(event.payload.errorMessage || "Export failed")));
} else {
@@ -6735,6 +6759,7 @@ export async function startTableExport(request: TableExportRequest, onProgress:
}
}
});
+ invoked = true;
await invoke("start_table_export", { request });
return await terminalProgress;
} catch (error) {
@@ -6742,6 +6767,9 @@ export async function startTableExport(request: TableExportRequest, onProgress:
settled = true;
unlisten?.();
}
+ if (reportCompletion && !invoked) {
+ throw new SnapshotCompletionError("failed", error instanceof Error ? error.message : String(error));
+ }
throw error instanceof BackendErrorException ? error : new BackendErrorException(error);
}
}
@@ -6750,8 +6778,9 @@ export async function cancelTableExport(exportId: string): Promise<void> {
return invoke("cancel_table_export", { exportId });
}
-export async function startQueryResultExport(request: QueryResultExportRequest, onProgress: (progress: TableExportProgress) => void): Promise<TableExportProgress> {
+export async function startQueryResultExport(request: QueryResultExportRequest, onProgress: (progress: TableExportProgress) => void, reportCompletion = false): Promise<TableExportProgress> {
let unlisten: UnlistenFn | undefined;
+ let invoked = false;
let settled = false;
let resolveTerminal: (progress: TableExportProgress) => void = () => {};
let rejectTerminal: (error: unknown) => void = () => {};
@@ -6772,7 +6801,9 @@ export async function startQueryResultExport(request: QueryResultExportRequest,
unlisten = await listen<TableExportProgress>("query-result-export-progress", (event) => {
if (event.payload.exportId !== request.exportId) return;
onProgress(event.payload);
- if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
+ if (event.payload.status === "Unknown") {
+ finish(() => rejectTerminal(new SnapshotCompletionError("unknown", event.payload.errorMessage || "Export cleanup completion was not confirmed")));
+ } else if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
if (event.payload.status === "Error") {
finish(() => rejectTerminal(new BackendErrorException(event.payload.errorMessage || "Export failed")));
} else {
@@ -6780,6 +6811,7 @@ export async function startQueryResultExport(request: QueryResultExportRequest,
}
}
});
+ invoked = true;
await invoke("start_query_result_export", { request });
return await terminalProgress;
} catch (error) {
@@ -6787,6 +6819,9 @@ export async function startQueryResultExport(request: QueryResultExportRequest,
settled = true;
unlisten?.();
}
+ if (reportCompletion && !invoked) {
+ throw new SnapshotCompletionError("failed", error instanceof Error ? error.message : String(error));
+ }
throw error instanceof BackendErrorException ? error : new BackendErrorException(error);
}
}
@@ -6806,20 +6841,24 @@ export async function beginDatabaseBackupSnapshot(connectionId: string, database
return invoke("begin_database_backup_snapshot", { connectionId, database, exportId: exportId || null });
}
-export async function exportDatabaseSql(request: DatabaseExportRequest, onProgress: (progress: ExportProgress) => void): Promise<void> {
- const unlisten: UnlistenFn = await listen<ExportProgress>("database-export-progress", (event) => {
- if (event.payload.exportId === request.exportId) {
- onProgress(event.payload);
- if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
- unlisten();
- }
- }
- });
+export async function exportDatabaseSql(request: DatabaseExportRequest, onProgress: (progress: ExportProgress) => void, reportCompletion = false): Promise<void> {
+ let unlisten: UnlistenFn | undefined;
+ let invoked = false;
try {
+ unlisten = await listen<ExportProgress>("database-export-progress", (event) => {
+ if (event.payload.exportId === request.exportId) {
+ onProgress(event.payload);
+ if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled" || event.payload.status === "Unknown") {
+ unlisten?.();
+ }
+ }
+ });
+ invoked = true;
await invoke("export_database_sql", { request });
- } catch (e) {
- unlisten();
- throw e;
+ } catch (error) {
+ unlisten?.();
+ if (reportCompletion && !invoked) throw new SnapshotCompletionError("failed", error instanceof Error ? error.message : String(error));
+ throw error;
}
}
diff --git a/apps/desktop/src/lib/dataGrid/largeValueSnapshot.ts b/apps/desktop/src/lib/dataGrid/largeValueSnapshot.ts
index 7795936e9c..e600aa587f 100644
--- a/apps/desktop/src/lib/dataGrid/largeValueSnapshot.ts
+++ b/apps/desktop/src/lib/dataGrid/largeValueSnapshot.ts
@@ -4,9 +4,14 @@ import type { QueryResult } from "@/types/database";
const MAX_MATERIALIZED_BYTES = 16 * 1024 * 1024;
-/** Abort only ends local waiting; the caller separately requests server cancellation. */
-export async function waitForLargeValueSnapshot<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
+/** By default abort ends local waiting; export leases can retain native completion instead. */
+export async function waitForLargeValueSnapshot<T>(promise: Promise<T>, signal?: AbortSignal, waitForNative = false): Promise<T> {
if (!signal) return promise;
+ if (waitForNative) {
+ const result = await promise;
+ signal.throwIfAborted();
+ return result;
+ }
let abort!: () => void;
try {
return await Promise.race([
@@ -23,12 +28,12 @@ export async function waitForLargeValueSnapshot<T>(promise: Promise<T>, signal?:
}
/** No cache: every request validates the original server locator's lifecycle. */
-export async function readLargeValueSnapshot(request: LargeValueRequest, isCurrent: () => boolean, consume: (chunk: LargeValueChunk) => Promise<void> | void, signal?: AbortSignal, readChunk = api.readLargeValueChunk): Promise<void> {
+export async function readLargeValueSnapshot(request: LargeValueRequest, isCurrent: () => boolean, consume: (chunk: LargeValueChunk) => Promise<void> | void, signal?: AbortSignal, readChunk = api.readLargeValueChunk, waitForNative = false): Promise<void> {
let offset = 0;
while (true) {
signal?.throwIfAborted();
if (!isCurrent()) throw new Error("LOB result context changed");
- const chunk = await waitForLargeValueSnapshot(readChunk({ ...request, offset, limit: 4096 }), signal);
+ const chunk = await waitForLargeValueSnapshot(readChunk({ ...request, offset, limit: 4096 }), signal, waitForNative);
signal?.throwIfAborted();
if (!isCurrent()) throw new Error("LOB result context changed");
if (chunk.status !== "ok") throw new Error(`LOB snapshot ${chunk.status}; execute the query again`);
@@ -51,7 +56,7 @@ export async function readLargeValueSnapshot(request: LargeValueRequest, isCurre
}
}
-export async function materializeLargeValueSnapshot(request: LargeValueRequest, isCurrent: () => boolean, signal?: AbortSignal, readChunk = api.readLargeValueChunk): Promise<string> {
+export async function materializeLargeValueSnapshot(request: LargeValueRequest, isCurrent: () => boolean, signal?: AbortSignal, readChunk = api.readLargeValueChunk, waitForNative = false): Promise<string> {
const chunks: string[] = [];
let bytes = 0;
let kind: LargeValueChunk["value_kind"] | undefined;
@@ -67,11 +72,12 @@ export async function materializeLargeValueSnapshot(request: LargeValueRequest,
},
signal,
readChunk,
+ waitForNative,
);
return (kind === "binary" ? "0x" : "") + chunks.join("");
}
-export async function materializeSnapshotResultRows(result: QueryResult, isCurrent: () => boolean, signal?: AbortSignal, executionId?: string): Promise<QueryResult["rows"]> {
+export async function materializeSnapshotResultRows(result: QueryResult, isCurrent: () => boolean, signal?: AbortSignal, executionId?: string, readOptions?: { waitForNative?: boolean; readChunk?: typeof api.readLargeValueChunk }): Promise<QueryResult["rows"]> {
const cells = result.large_value_cells ?? [];
if (!cells.some((cell) => cell.value_ref)) return result.rows;
const context = result.large_value_context;
@@ -80,7 +86,7 @@ export async function materializeSnapshotResultRows(result: QueryResult, isCurre
let totalBytes = 0;
for (const cell of cells) {
if (!cell.value_ref) throw new Error("This result includes a value without a snapshot reference");
- const value = await materializeLargeValueSnapshot({ ...context, valueRef: cell.value_ref, executionId }, isCurrent, signal);
+ const value = await materializeLargeValueSnapshot({ ...context, valueRef: cell.value_ref, executionId }, isCurrent, signal, readOptions?.readChunk, readOptions?.waitForNative);
totalBytes += new TextEncoder().encode(value).length;
if (totalBytes > 64 * 1024 * 1024) throw new Error("LOB result exceeds the 64 MiB export limit; download individual complete values");
const row = rows[cell.row_index];
diff --git a/apps/desktop/src/lib/dataGrid/legacyLargeValueExport.ts b/apps/desktop/src/lib/dataGrid/legacyLargeValueExport.ts
new file mode 100644
index 0000000000..d7851c6402
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/legacyLargeValueExport.ts
@@ -0,0 +1,177 @@
+import * as api from "@/lib/backend/api";
+import type { CellValue } from "./cellValue";
+import { buildDataGridContextFilterCondition } from "./dataGridSql";
+import { buildTableSelectSql } from "@/lib/table/tableSelectSql";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+
+export interface LegacyLargeValueContext {
+ databaseType: DatabaseType | undefined;
+ connectionId: string | undefined;
+ executionDatabase: string;
+ tableMeta: { catalog?: string; database?: string; schema?: string; tableName: string; tableType?: string; columns: ColumnInfo[]; primaryKeys: string[] } | undefined;
+ sourceColumns: string[];
+ rows: CellValue[][];
+ identifierQuote: string | undefined;
+ serverVersion: string | undefined;
+ includeDatabaseName: boolean;
+ includeRowId: boolean;
+ timeoutSecs: number;
+}
+
+export interface LegacyLargeValueCellRequest {
+ rowId: number;
+ sourceIndex: number;
+ columnIndex: number;
+ originalBytes: number;
+}
+export type LegacyResolvedLargeValueCells = Map<number, Map<number, CellValue>>;
+export interface CapturedLegacyLargeValueExport {
+ unavailableReason?: string;
+ read?: (signal: AbortSignal) => Promise<LegacyResolvedLargeValueCells>;
+}
+interface ReaderOptions {
+ uuid: () => string;
+ translate: (key: string) => string;
+ translateBackendError: (error: unknown) => string;
+}
+
+export function legacyLargeValueIdentityKey(row: readonly CellValue[], indexes: readonly number[]): string {
+ return indexes
+ .map((index) => {
+ const value = row[index] ?? null;
+ return value === null ? "null" : `${typeof value}:${JSON.stringify(value)}`;
+ })
+ .join("\u001f");
+}
+
+export function chunkLegacyLargeValueRequests(requests: LegacyLargeValueCellRequest[], databaseType: DatabaseType | undefined): LegacyLargeValueCellRequest[][] {
+ const maxRows = databaseType === "postgres" ? 1 : 200;
+ const chunks: LegacyLargeValueCellRequest[][] = [];
+ let chunk: LegacyLargeValueCellRequest[] = [];
+ let bytes = 0;
+ for (const request of requests) {
+ if (chunk.length && (chunk.length >= maxRows || bytes + request.originalBytes > 64 * 1024 * 1024)) {
+ chunks.push(chunk);
+ chunk = [];
+ bytes = 0;
+ }
+ chunk.push(request);
+ bytes += request.originalBytes;
+ }
+ if (chunk.length) chunks.push(chunk);
+ return chunks;
+}
+
+export async function legacyLargeValueRowPredicate(context: LegacyLargeValueContext, sourceIndex: number, primaryKeyIndexes: number[], options: ReaderOptions): Promise<string> {
+ const row = context.rows[sourceIndex];
+ if (!row) throw new Error(options.translate("grid.largeValueRowUnavailable"));
+ const table = context.tableMeta!;
+ const conditions = await Promise.all(
+ table.primaryKeys.map((columnName, index) =>
+ buildDataGridContextFilterCondition({
+ databaseType: context.databaseType,
+ identifierQuote: context.identifierQuote,
+ columnName,
+ columnInfo: table.columns.find((column) => column.name.toLocaleLowerCase() === columnName.toLocaleLowerCase()),
+ mode: "equals",
+ value: row[primaryKeyIndexes[index]!] ?? null,
+ }),
+ ),
+ );
+ if (conditions.some((condition) => !condition)) throw new Error(options.translate("grid.largeValueRowUnavailable"));
+ return conditions.map((condition) => `(${condition})`).join(" AND ");
+}
+
+export async function fetchLegacyLargeValueRequestChunk(context: LegacyLargeValueContext, columnIndex: number, requests: LegacyLargeValueCellRequest[], primaryKeyIndexes: number[], resolved: LegacyResolvedLargeValueCells, options: ReaderOptions, beforeRead?: () => void): Promise<void> {
+ const table = context.tableMeta!;
+ const sourceColumn = context.sourceColumns[columnIndex];
+ if (!sourceColumn) throw new Error(options.translate("grid.largeValueColumnUnavailable"));
+ const predicates = await Promise.all(requests.map((request) => legacyLargeValueRowPredicate(context, request.sourceIndex, primaryKeyIndexes, options)));
+ const selectedColumns = [...new Set([...table.primaryKeys, sourceColumn])];
+ const sql = await buildTableSelectSql({
+ databaseType: context.databaseType,
+ serverVersion: context.serverVersion,
+ identifierQuote: context.identifierQuote,
+ database: table.database,
+ schema: table.schema,
+ tableName: table.tableName,
+ tableType: table.tableType,
+ catalog: table.catalog,
+ columns: selectedColumns,
+ includeDatabaseName: context.includeDatabaseName,
+ primaryKeys: table.primaryKeys,
+ whereInput: predicates.map((predicate) => `(${predicate})`).join(" OR "),
+ limit: requests.length,
+ offset: 0,
+ includeRowId: context.includeRowId,
+ });
+ beforeRead?.();
+ const results = await api.executeMulti(context.connectionId!, context.executionDatabase, sql, undefined, options.uuid(), { maxRows: requests.length, fetchSize: requests.length, timeoutSecs: context.timeoutSecs }).catch((error) => {
+ if (beforeRead) throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ throw error;
+ });
+ const failures = results.filter((result) => result.execution_error);
+ if (beforeRead && failures.length) {
+ const unknown = failures.find((result) => result.error?.operationOutcome !== "not_started");
+ const failed = unknown ?? failures[0]!;
+ throw new SnapshotCompletionError(unknown ? "unknown" : "failed", failed.error ? options.translateBackendError(failed.error) : String(failed.rows?.[0]?.[0] ?? options.translate("grid.largeValueLoadFailed")));
+ }
+ const result = results[0];
+ if (!result || result.execution_error) throw new Error(result?.error ? options.translateBackendError(result.error) : String(result?.rows?.[0]?.[0] ?? options.translate("grid.largeValueLoadFailed")));
+ const resultIndexes = selectedColumns.map((column) => {
+ if (!beforeRead) return result.columns.findIndex((name) => name.toLocaleLowerCase() === column.toLocaleLowerCase());
+ const exact = result.columns.flatMap((name, index) => (name === column ? [index] : []));
+ if (exact.length) return exact.length === 1 ? exact[0]! : -1;
+ const folded = result.columns.flatMap((name, index) => (name.toLocaleLowerCase() === column.toLocaleLowerCase() ? [index] : []));
+ return folded.length === 1 ? folded[0]! : -1;
+ });
+ if (resultIndexes.some((index) => index < 0)) throw new Error(options.translate("grid.largeValueColumnUnavailable"));
+ const keyIndexes = resultIndexes.slice(0, table.primaryKeys.length);
+ const valueIndex = resultIndexes[selectedColumns.indexOf(sourceColumn)]!;
+ if (beforeRead && result.large_value_cells?.some((cell) => cell.column_index === valueIndex || keyIndexes.includes(cell.column_index))) throw new Error(options.translate("grid.largeValueLoadFailed"));
+ const values = new Map<string, CellValue>();
+ for (const row of result.rows) {
+ const identity = legacyLargeValueIdentityKey(row, keyIndexes);
+ if (beforeRead && values.has(identity)) throw new Error(options.translate("grid.largeValueRowUnavailable"));
+ values.set(identity, row[valueIndex] ?? null);
+ }
+ for (const request of requests) {
+ const row = context.rows[request.sourceIndex];
+ const identity = row ? legacyLargeValueIdentityKey(row, primaryKeyIndexes) : "";
+ if (!values.has(identity)) throw new Error(options.translate("grid.largeValueRowUnavailable"));
+ const rowValues = resolved.get(request.rowId) ?? new Map<number, CellValue>();
+ rowValues.set(columnIndex, values.get(identity) ?? null);
+ resolved.set(request.rowId, rowValues);
+ }
+}
+
+export async function resolveCapturedLegacyLargeValueCells(context: LegacyLargeValueContext, requests: LegacyLargeValueCellRequest[], signal: AbortSignal, options: ReaderOptions, assertCurrent: () => void): Promise<LegacyResolvedLargeValueCells> {
+ const resolved: LegacyResolvedLargeValueCells = new Map();
+ if (!requests.length) return resolved;
+ const check = () => {
+ if (signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ assertCurrent();
+ };
+ try {
+ check();
+ const keyIndexes = context.tableMeta?.primaryKeys.map((name) => context.sourceColumns.findIndex((column) => column.toLocaleLowerCase() === name.toLocaleLowerCase())) ?? [];
+ if (!["mysql", "postgres", "oracle", "db2"].includes(context.databaseType ?? "") || !context.tableMeta?.tableName || !keyIndexes.length || keyIndexes.some((index) => index < 0)) throw new Error(options.translate("grid.largeValueNeedsRowIdentifier"));
+ const byColumn = new Map<number, LegacyLargeValueCellRequest[]>();
+ for (const request of requests) {
+ const column = byColumn.get(request.columnIndex) ?? [];
+ column.push(request);
+ byColumn.set(request.columnIndex, column);
+ }
+ for (const [columnIndex, column] of byColumn)
+ for (const chunk of chunkLegacyLargeValueRequests(column, context.databaseType)) {
+ check();
+ await fetchLegacyLargeValueRequestChunk(context, columnIndex, chunk, keyIndexes, resolved, options, check);
+ check();
+ }
+ return resolved;
+ } catch (error) {
+ if (error instanceof SnapshotCompletionError) throw error;
+ throw new SnapshotCompletionError("failed", error instanceof Error ? error.message : String(error));
+ }
+}
diff --git a/apps/desktop/src/lib/export/__tests__/databaseExportCompletion.spec.ts b/apps/desktop/src/lib/export/__tests__/databaseExportCompletion.spec.ts
new file mode 100644
index 0000000000..6aef8e5bb0
--- /dev/null
+++ b/apps/desktop/src/lib/export/__tests__/databaseExportCompletion.spec.ts
@@ -0,0 +1,129 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { runDatabaseExportUntilTerminal, runWithDatabaseBackupSnapshot } from "../databaseExport";
+import { SnapshotCompletionError } from "../snapshotCompletion";
+import type { DatabaseExportRequest, ExportProgress } from "@/lib/backend/api";
+const mocks = vi.hoisted(() => ({ export: vi.fn(), begin: vi.fn(), rollback: vi.fn() }));
+vi.mock("@/lib/backend/api.ts", () => ({ exportDatabaseSql: mocks.export, beginDatabaseBackupSnapshot: mocks.begin, rollbackManualTransaction: mocks.rollback }));
+const request = { exportId: "export-1", connectionId: "mysql-1", database: "app", filePath: "app.sql" } as DatabaseExportRequest;
+const done: ExportProgress = { exportId: "export-1", currentObject: "T", objectIndex: 1, totalObjects: 1, rowsExported: 7, totalRows: 7, status: "Done", error: null };
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (error: Error) => void;
+ const promise = new Promise<T>((yes, no) => {
+ resolve = yes;
+ reject = no;
+ });
+ return { promise, resolve, reject };
+}
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.begin.mockResolvedValue({ sessionId: "snapshot-1" });
+ mocks.rollback.mockReset().mockResolvedValue(undefined);
+});
+describe("native queued database export completion", () => {
+ it("waits for the terminal event after the actual native API acknowledges startup", async () => {
+ let progress!: (value: ExportProgress) => void;
+ mocks.export.mockImplementationOnce(async (_request, callback) => {
+ progress = callback;
+ });
+ let settled = false;
+ const pending = runDatabaseExportUntilTerminal(request, vi.fn(), true).then((value) => {
+ settled = true;
+ return value;
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ progress(done);
+ expect(await pending).toEqual(done);
+ });
+ it("waits for the actual invoke after terminal progress", async () => {
+ const native = deferred<void>();
+ mocks.export.mockImplementationOnce((_request, progress) => {
+ progress(done);
+ return native.promise;
+ });
+ let settled = false;
+ const pending = runDatabaseExportUntilTerminal(request, vi.fn(), true).then((value) => {
+ settled = true;
+ return value;
+ });
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ native.resolve();
+ expect(await pending).toEqual(done);
+ });
+ it.each(["Done", "Error", "Cancelled"] as const)("preserves confirmed %s terminal evidence despite a subsequent invoke rejection", async (status) => {
+ const terminal = { ...done, status, error: status === "Error" ? "export failed" : null };
+ mocks.export.mockImplementationOnce(async (_request, progress) => {
+ progress(terminal);
+ throw new Error("invoke reply lost");
+ });
+ const pending = runDatabaseExportUntilTerminal(request, vi.fn(), true);
+ if (status === "Error") await expect(pending).rejects.toMatchObject({ status: "failed", message: "export failed" });
+ else expect(await pending).toEqual(terminal);
+ });
+ it("does not infer completion from an invoke rejection without terminal evidence", async () => {
+ mocks.export.mockRejectedValueOnce(new Error("invoke reply lost"));
+ await expect(runDatabaseExportUntilTerminal(request, vi.fn(), true)).rejects.toMatchObject({ status: "unknown" });
+ });
+ it("classifies a confirmed pre-invoke failure as failed instead of unknown", async () => {
+ mocks.export.mockRejectedValueOnce(new SnapshotCompletionError("failed", "listener unavailable"));
+ await expect(runDatabaseExportUntilTerminal(request, vi.fn(), true)).rejects.toMatchObject({ status: "failed", message: "listener unavailable" });
+ });
+ it("preserves the native cleanup-unknown outcome", async () => {
+ mocks.export.mockImplementationOnce(async (_request, progress) => {
+ progress({ ...done, status: "Unknown", error: "session close unknown" });
+ });
+ await expect(runDatabaseExportUntilTerminal(request, vi.fn(), true)).rejects.toMatchObject({ status: "unknown", message: "session close unknown" });
+ });
+ it("keeps the old progress-based completion contract by default", async () => {
+ const native = deferred<void>();
+ mocks.export.mockImplementationOnce((_request, progress) => {
+ progress(done);
+ return native.promise;
+ });
+ expect(await runDatabaseExportUntilTerminal(request, vi.fn())).toEqual(done);
+ native.resolve();
+ });
+ it("holds successful snapshot work until rollback actually returns", async () => {
+ const rollback = deferred<void>();
+ mocks.rollback.mockReturnValueOnce(rollback.promise);
+ let settled = false;
+ const pending = runWithDatabaseBackupSnapshot({ connectionId: "mysql-1", database: "app", enabled: true, reportCompletion: true }, async () => done).then((value) => {
+ settled = true;
+ return value;
+ });
+ await vi.waitFor(() => expect(mocks.rollback).toHaveBeenCalledWith("snapshot-1"));
+ expect(settled).toBe(false);
+ rollback.resolve();
+ expect(await pending).toEqual(done);
+ });
+ it.each(["success", "failure"] as const)("reports rollback failure as unknown after operation %s", async (outcome) => {
+ mocks.rollback.mockRejectedValueOnce(new Error("rollback reply lost"));
+ await expect(
+ runWithDatabaseBackupSnapshot({ connectionId: "mysql-1", database: "app", enabled: true, reportCompletion: true }, async () => {
+ if (outcome === "failure") throw new SnapshotCompletionError("failed", "export failed");
+ return done;
+ }),
+ ).rejects.toMatchObject({ status: "unknown", message: "rollback reply lost" });
+ });
+ it("preserves an earlier unknown even if snapshot cleanup also fails", async () => {
+ mocks.rollback.mockRejectedValueOnce(new Error("rollback reply lost"));
+ const unknown = new SnapshotCompletionError("unknown", "export reply lost");
+ await expect(
+ runWithDatabaseBackupSnapshot({ connectionId: "mysql-1", database: "app", enabled: true, reportCompletion: true }, async () => {
+ throw unknown;
+ }),
+ ).rejects.toBe(unknown);
+ });
+ it("keeps the old cleanup suppression contract by default", async () => {
+ mocks.rollback.mockRejectedValueOnce(new Error("rollback reply lost"));
+ const failed = new Error("export failed");
+ await expect(
+ runWithDatabaseBackupSnapshot({ connectionId: "mysql-1", database: "app", enabled: true }, async () => {
+ throw failed;
+ }),
+ ).rejects.toBe(failed);
+ });
+});
diff --git a/apps/desktop/src/lib/export/__tests__/manualExportQueue.spec.ts b/apps/desktop/src/lib/export/__tests__/manualExportQueue.spec.ts
new file mode 100644
index 0000000000..5ae959b689
--- /dev/null
+++ b/apps/desktop/src/lib/export/__tests__/manualExportQueue.spec.ts
@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ManualExportMode, ManualExportQueueState } from "../manualExportQueue";
+
+function operation(id: string, mode: ManualExportMode = "queued") {
+ let finish!: (outcome: "settled" | "unknown") => void;
+ let fail!: (error: Error) => void;
+ const completion = new Promise<"settled" | "unknown">((resolve, reject) => {
+ finish = resolve;
+ fail = reject;
+ });
+ const states: ManualExportQueueState[] = [];
+ return {
+ id,
+ mode,
+ run: vi.fn(() => completion),
+ onStateChange: vi.fn((state: ManualExportQueueState) => states.push(state)),
+ states,
+ finish,
+ fail,
+ };
+}
+
+describe("manual export queue", () => {
+ beforeEach(() => vi.resetModules());
+
+ it("starts queued operations in FIFO order only after actual settlement", async () => {
+ const { submitManualExport } = await import("../manualExportQueue");
+ const a = operation("a");
+ const b = operation("b");
+ const c = operation("c");
+ [a, b, c].forEach(submitManualExport);
+ expect(a.run).toHaveBeenCalledOnce();
+ expect(b.run).not.toHaveBeenCalled();
+ expect(c.run).not.toHaveBeenCalled();
+ a.finish("settled");
+ await Promise.resolve();
+ expect(b.run).toHaveBeenCalledOnce();
+ expect(c.run).not.toHaveBeenCalled();
+ b.finish("settled");
+ await Promise.resolve();
+ expect(c.run).toHaveBeenCalledOnce();
+ c.finish("settled");
+ await Promise.resolve();
+ });
+
+ it("keeps immediate exports independent but waits for all active exports before dequeuing", async () => {
+ const { submitManualExport } = await import("../manualExportQueue");
+ const a = operation("a");
+ const b = operation("b");
+ const immediate = operation("immediate", "immediate");
+ submitManualExport(a);
+ submitManualExport(b);
+ submitManualExport(immediate);
+ expect(immediate.run).toHaveBeenCalledOnce();
+ a.finish("settled");
+ await Promise.resolve();
+ expect(b.run).not.toHaveBeenCalled();
+ immediate.finish("settled");
+ await Promise.resolve();
+ expect(b.run).toHaveBeenCalledOnce();
+ b.finish("settled");
+ await Promise.resolve();
+ });
+
+ it("cancels a waiting operation without ever running it", async () => {
+ const { submitManualExport } = await import("../manualExportQueue");
+ const a = operation("a");
+ const b = operation("b");
+ submitManualExport(a);
+ const handle = submitManualExport(b);
+ expect(handle.cancelQueued()).toBe(true);
+ expect(handle.cancelQueued()).toBe(false);
+ expect(b.states).toEqual(["queued", "cancelled"]);
+ a.finish("settled");
+ await Promise.resolve();
+ expect(b.run).not.toHaveBeenCalled();
+ });
+
+ it.each(["unknown", "rejected"])("does not release execution ownership after %s completion", async (outcome) => {
+ const { submitManualExport } = await import("../manualExportQueue");
+ const a = operation("a");
+ const b = operation("b");
+ submitManualExport(a);
+ const waiting = submitManualExport(b);
+ if (outcome === "unknown") a.finish("unknown");
+ else a.fail(new Error("connection interrupted after starting"));
+ await Promise.resolve();
+ expect(a.states.at(-1)).toBe("unknown");
+ expect(b.run).not.toHaveBeenCalled();
+ expect(waiting.cancelQueued()).toBe(true);
+ });
+
+ it("starts the next queued operation once an unknown one is explicitly released", async () => {
+ const { releaseManualExport, submitManualExport } = await import("../manualExportQueue");
+ const a = operation("a");
+ const b = operation("b");
+ submitManualExport(a);
+ submitManualExport(b);
+ a.finish("unknown");
+ await Promise.resolve();
+ expect(b.run).not.toHaveBeenCalled();
+
+ releaseManualExport("a");
+ expect(b.run).toHaveBeenCalledOnce();
+ expect(a.run).toHaveBeenCalledOnce();
+ expect(a.states.at(-1)).toBe("unknown");
+
+ b.finish("settled");
+ await Promise.resolve();
+ });
+});
diff --git a/apps/desktop/src/lib/export/databaseExport.ts b/apps/desktop/src/lib/export/databaseExport.ts
index 85d2a7ecbd..498358fcc4 100644
--- a/apps/desktop/src/lib/export/databaseExport.ts
+++ b/apps/desktop/src/lib/export/databaseExport.ts
@@ -5,6 +5,7 @@ import { uuid } from "@/lib/common/utils.ts";
import { SINGLE_DATABASE_TYPES } from "@/lib/database/databaseCapabilitySets";
import { isXuguSyntheticScope } from "@/lib/sidebar/xuguPublicSynonyms";
import type { SqlInsertDialect } from "@/lib/export/sqlInsertMode";
+import { SnapshotCompletionError } from "@/lib/export/snapshotCompletion";
export const DATABASE_EXPORT_ROW_LIMIT = 10_000;
export const DATABASE_EXPORT_PAGE_SIZE = 500;
@@ -102,6 +103,7 @@ export interface DatabaseBackupSnapshotOptions {
connectionId: string;
database: string;
enabled: boolean;
+ reportCompletion?: boolean;
}
export function buildInsertStatements(options: BuildExportInsertStatementsOptions): Promise<string[]> {
@@ -128,7 +130,38 @@ export function shouldUseDatabaseBackupSnapshot(databaseType: DatabaseType | und
return desktopRuntime && includeData && (databaseType === "mysql" || databaseType === "postgres");
}
-export async function runDatabaseExportUntilTerminal(request: api.DatabaseExportRequest, onProgress: (progress: api.ExportProgress) => void): Promise<api.ExportProgress> {
+export async function runDatabaseExportUntilTerminal(request: api.DatabaseExportRequest, onProgress: (progress: api.ExportProgress) => void, reportCompletion = false): Promise<api.ExportProgress> {
+ if (reportCompletion) {
+ const outcome: { terminal?: api.ExportProgress } = {};
+ let complete!: (progress: api.ExportProgress) => void;
+ const terminalProgress = new Promise<api.ExportProgress>((resolve) => {
+ complete = resolve;
+ });
+ try {
+ await api.exportDatabaseSql(
+ request,
+ (progress) => {
+ if (progress.status === "Done" || progress.status === "Cancelled" || progress.status === "Error" || progress.status === "Unknown") {
+ outcome.terminal = progress;
+ complete(progress);
+ }
+ onProgress(progress);
+ },
+ reportCompletion,
+ );
+ } catch (error) {
+ if (!outcome.terminal) {
+ // A failed SnapshotCompletionError proves the native invoke never
+ // started; a generic rejection may still have an export in flight.
+ if (error instanceof SnapshotCompletionError) throw error;
+ throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ }
+ }
+ const terminal = await terminalProgress;
+ if (terminal.status === "Unknown") throw new SnapshotCompletionError("unknown", terminal.error || "Export cleanup completion was not confirmed");
+ if (terminal.status === "Error") throw new SnapshotCompletionError("failed", terminal.error || "Export failed");
+ return terminal;
+ }
return new Promise<api.ExportProgress>((resolve, reject) => {
api
.exportDatabaseSql(request, (progress) => {
@@ -146,6 +179,32 @@ export async function runDatabaseExportUntilTerminal(request: api.DatabaseExport
export async function runWithDatabaseBackupSnapshot<T>(options: DatabaseBackupSnapshotOptions, operation: (snapshotSessionId: string | undefined) => Promise<T>, shouldPropagateCleanupError: (result: T) => boolean = () => true): Promise<T> {
if (!options.enabled) return operation(undefined);
+ if (options.reportCompletion) {
+ let sessionId: string;
+ try {
+ sessionId = (await api.beginDatabaseBackupSnapshot(options.connectionId, options.database)).sessionId;
+ } catch (error) {
+ throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ }
+ let result: T | undefined;
+ let operationError: unknown;
+ let failed = false;
+ try {
+ result = await operation(sessionId);
+ } catch (error) {
+ failed = true;
+ operationError = error;
+ }
+ try {
+ await api.rollbackManualTransaction(sessionId);
+ } catch (error) {
+ if (operationError instanceof SnapshotCompletionError && operationError.status === "unknown") throw operationError;
+ throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ }
+ if (failed) throw operationError;
+ return result as T;
+ }
+
const snapshot = await api.beginDatabaseBackupSnapshot(options.connectionId, options.database);
let result: T | undefined;
let operationCompleted = false;
diff --git a/apps/desktop/src/lib/export/exportExecutionMode.ts b/apps/desktop/src/lib/export/exportExecutionMode.ts
new file mode 100644
index 0000000000..d1d241b10a
--- /dev/null
+++ b/apps/desktop/src/lib/export/exportExecutionMode.ts
@@ -0,0 +1,29 @@
+import { createApp } from "vue";
+import ExportExecutionModeDialog from "@/components/export/ExportExecutionModeDialog.vue";
+import i18n from "@/i18n";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import type { ManualExportMode } from "./manualExportQueue";
+
+export function showExportExecutionModeDialog(): Promise<ManualExportMode | null> {
+ if (!isTauriRuntime() || typeof document === "undefined") return Promise.resolve("immediate");
+ return new Promise((resolve) => {
+ const container = document.createElement("div");
+ document.body.append(container);
+ let settled = false;
+ let app: ReturnType<typeof createApp> | undefined;
+ const finish = (mode: ManualExportMode | null) => {
+ if (settled) return;
+ settled = true;
+ resolve(mode);
+ app?.unmount();
+ container.remove();
+ };
+ app = createApp(ExportExecutionModeDialog, {
+ open: true,
+ onConfirm: (mode: ManualExportMode) => finish(mode),
+ onCancel: () => finish(null),
+ });
+ app.use(i18n);
+ app.mount(container);
+ });
+}
diff --git a/apps/desktop/src/lib/export/manualExportQueue.ts b/apps/desktop/src/lib/export/manualExportQueue.ts
new file mode 100644
index 0000000000..758bdf049a
--- /dev/null
+++ b/apps/desktop/src/lib/export/manualExportQueue.ts
@@ -0,0 +1,66 @@
+export type ManualExportMode = "immediate" | "queued";
+export type ManualExportQueueState = "queued" | "running" | "cancelled" | "settled" | "unknown";
+
+export interface ManualExportOperation {
+ id: string;
+ mode: ManualExportMode;
+ run: () => Promise<"settled" | "unknown">;
+ onStateChange: (state: ManualExportQueueState, error?: unknown) => void;
+}
+
+const pending: ManualExportOperation[] = [];
+const active = new Set<string>();
+
+function startNext() {
+ if (active.size > 0) return;
+ const operation = pending.shift();
+ if (operation) start(operation);
+}
+
+function start(operation: ManualExportOperation) {
+ active.add(operation.id);
+ operation.onStateChange("running");
+ void (async () => {
+ let outcome: "settled" | "unknown";
+ try {
+ outcome = await operation.run();
+ } catch (error) {
+ operation.onStateChange("unknown", error);
+ return;
+ }
+ operation.onStateChange(outcome);
+ if (outcome === "settled") {
+ active.delete(operation.id);
+ startNext();
+ }
+ })();
+}
+
+/**
+ * Acknowledge an operation whose outcome is unknown and hand its queue slot to
+ * the next waiter. Never retries the released operation or touches the backend.
+ */
+export function releaseManualExport(id: string) {
+ active.delete(id);
+ startNext();
+}
+
+export function submitManualExport(operation: ManualExportOperation) {
+ if (operation.mode === "immediate") {
+ start(operation);
+ } else {
+ pending.push(operation);
+ operation.onStateChange("queued");
+ startNext();
+ }
+
+ return {
+ cancelQueued() {
+ const index = pending.indexOf(operation);
+ if (index < 0) return false;
+ pending.splice(index, 1);
+ operation.onStateChange("cancelled");
+ return true;
+ },
+ };
+}
diff --git a/apps/desktop/src/lib/export/snapshotCompletion.ts b/apps/desktop/src/lib/export/snapshotCompletion.ts
new file mode 100644
index 0000000000..e1d03f3216
--- /dev/null
+++ b/apps/desktop/src/lib/export/snapshotCompletion.ts
@@ -0,0 +1,22 @@
+export type SnapshotCompletionStatus = "failed" | "cancelled" | "unknown";
+
+export interface ExportReadControl {
+ signal: AbortSignal;
+}
+
+export class SnapshotCompletionError extends Error {
+ constructor(
+ readonly status: SnapshotCompletionStatus,
+ message: string,
+ ) {
+ super(message);
+ this.name = "SnapshotCompletionError";
+ }
+}
+
+export function unwrapSnapshotCompletion<T>(outcome: unknown): T {
+ if (!outcome || typeof outcome !== "object" || !("status" in outcome)) throw new Error("Invalid snapshot completion response");
+ if (outcome.status === "succeeded" && "value" in outcome) return outcome.value as T;
+ if ((outcome.status === "failed" || outcome.status === "cancelled" || outcome.status === "unknown") && "message" in outcome && typeof outcome.message === "string") throw new SnapshotCompletionError(outcome.status, outcome.message);
+ throw new Error("Invalid snapshot completion response");
+}
diff --git a/apps/desktop/src/lib/export/sqlInsertMode.ts b/apps/desktop/src/lib/export/sqlInsertMode.ts
index b3f21ef691..b39db14279 100644
--- a/apps/desktop/src/lib/export/sqlInsertMode.ts
+++ b/apps/desktop/src/lib/export/sqlInsertMode.ts
@@ -1,6 +1,7 @@
import { createApp } from "vue";
import SqlInsertModeDialog from "@/components/export/SqlInsertModeDialog.vue";
import i18n from "@/i18n";
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
export type SqlInsertMode = "batch" | "single";
export type SqlInsertDialect = "source" | "standard";
@@ -15,12 +16,13 @@ export interface SqlExportOptions {
insertMode: SqlInsertMode;
splitMaxMb?: number;
selectedColumns?: SqlExportColumnSelection[];
+ executionMode?: ManualExportMode;
}
export const DEFAULT_SQL_INSERT_MODE: SqlInsertMode = "batch";
export const DEFAULT_SQL_INSERT_DIALECT: SqlInsertDialect = "source";
-export function showSqlInsertModeDialog(options: { allowSplit?: boolean; columns?: SqlExportColumnSelection[] } = {}): Promise<SqlExportOptions | null> {
+export function showSqlInsertModeDialog(options: { allowSplit?: boolean; columns?: SqlExportColumnSelection[]; showExecutionMode?: boolean } = {}): Promise<SqlExportOptions | null> {
if (typeof document === "undefined") {
return Promise.resolve({
insertMode: DEFAULT_SQL_INSERT_MODE,
@@ -44,6 +46,7 @@ export function showSqlInsertModeDialog(options: { allowSplit?: boolean; columns
open: true,
allowSplit: options.allowSplit === true,
columns: options.columns,
+ showExecutionMode: options.showExecutionMode,
onConfirm: (options: SqlExportOptions) => finish(options),
onCancel: () => finish(null),
});
diff --git a/apps/desktop/src/lib/export/xlsxHeader.ts b/apps/desktop/src/lib/export/xlsxHeader.ts
index b45559428d..c0b70be218 100644
--- a/apps/desktop/src/lib/export/xlsxHeader.ts
+++ b/apps/desktop/src/lib/export/xlsxHeader.ts
@@ -1,8 +1,11 @@
+import type { ManualExportMode } from "@/lib/export/manualExportQueue";
+
export type XlsxHeaderMode = "name" | "comment" | "name-comment" | "name-comment-rows";
export interface XlsxExportOptions {
headerMode: XlsxHeaderMode;
autoFilter: boolean;
+ executionMode?: ManualExportMode;
}
export function hasXlsxHeaderComments(comments: readonly (string | null | undefined)[] | undefined): boolean {
diff --git a/apps/desktop/src/lib/metadata/__tests__/tableMetadataCache.columns.spec.ts b/apps/desktop/src/lib/metadata/__tests__/tableMetadataCache.columns.spec.ts
index f94bc1d82b..ff725a3965 100644
--- a/apps/desktop/src/lib/metadata/__tests__/tableMetadataCache.columns.spec.ts
+++ b/apps/desktop/src/lib/metadata/__tests__/tableMetadataCache.columns.spec.ts
@@ -25,7 +25,7 @@ vi.mock("@/lib/backend/api", () => ({
listIndexes: mocks.listIndexes,
}));
-import { clearTableMetadataCache, getCachedTableMetadata, invalidateTableMetadataCache, loadTableColumns, loadTableMetadata, TABLE_METADATA_CACHE_TTL_MS } from "@/lib/metadata/tableMetadataCache";
+import { clearTableMetadataCache, getCachedTableMetadata, invalidateTableMetadataCache, loadTableColumns, loadTableMetadata, loadTableMetadataForExport, TABLE_METADATA_CACHE_TTL_MS } from "@/lib/metadata/tableMetadataCache";
// The coordinator starts its loader on a microtask (Promise.resolve().then), so
// flush before asserting remote call counts.
@@ -55,6 +55,43 @@ describe("tableMetadataCache columns facet request counts", () => {
mocks.listIndexes.mockResolvedValue([]);
});
+ it("loads export metadata facets serially through the original request boundary", async () => {
+ let finishColumns!: (columns: ColumnInfo[]) => void;
+ mocks.getColumns.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ finishColumns = resolve;
+ }),
+ );
+ const read = vi.fn(async <T>(request: () => Promise<T>) => request());
+ const pending = loadTableMetadataForExport(usersRequest, read);
+ await flush();
+ expect(mocks.getColumns).toHaveBeenCalledOnce();
+ expect(mocks.listIndexes).not.toHaveBeenCalled();
+ finishColumns([column("id")]);
+ const result = await pending;
+ expect(read).toHaveBeenCalledTimes(2);
+ expect(result.primaryKeys).toEqual(["id"]);
+ expect(result.rowIdentityResolved).toBe(true);
+ });
+
+ it("propagates export index discovery rejection instead of swallowing it", async () => {
+ mocks.listIndexes.mockRejectedValueOnce(new Error("indexes unavailable"));
+ await expect(loadTableMetadataForExport(usersRequest, (request) => request())).rejects.toThrow("indexes unavailable");
+ expect(mocks.getColumns).toHaveBeenCalledOnce();
+ expect(mocks.listIndexes).toHaveBeenCalledOnce();
+ });
+
+ it("resolves a synonym before loading its export indexes", async () => {
+ mocks.getColumns.mockResolvedValueOnce([{ ...column("ItemId"), is_primary_key: false, resolved_schema: "MixedOwner", resolved_table: "ActualItems", resolved_object_type: "TABLE" }]);
+ mocks.listIndexes.mockResolvedValueOnce([{ name: "ITEMS_PK", columns: ["ItemId"], is_primary: true, is_unique: true }]);
+ const request = { connectionId: "ob-1", database: "service", schema: "AppOwner", tableName: "ItemsAlias", tableType: "SYNONYM", databaseType: "oceanbase-oracle" };
+ const metadata = await loadTableMetadataForExport(request, (read) => read());
+ expect(mocks.listIndexes).toHaveBeenCalledExactlyOnceWith("ob-1", "service", "MixedOwner", "ActualItems", undefined);
+ expect(metadata.primaryKeys).toEqual(["ItemId"]);
+ expect(metadata.columns[0]!.resolved_table).toBe("ActualItems");
+ });
+
it("does not treat failed index discovery as a complete cacheable row identity", async () => {
mocks.getColumns.mockResolvedValue([{ ...column("id"), is_primary_key: false }]);
mocks.listIndexes.mockRejectedValueOnce(new Error("indexes unavailable"));
diff --git a/apps/desktop/src/lib/metadata/tableMetadataCache.ts b/apps/desktop/src/lib/metadata/tableMetadataCache.ts
index 882b00e74e..906a479764 100644
--- a/apps/desktop/src/lib/metadata/tableMetadataCache.ts
+++ b/apps/desktop/src/lib/metadata/tableMetadataCache.ts
@@ -1,7 +1,7 @@
import type { ColumnInfo, DatabaseType, IndexInfo, QueryTab } from "@/types/database";
import * as api from "@/lib/backend/api";
import { editableRowIdentifierColumns, physicalTablePrimaryKeys, uniqueKeyModelColumns } from "@/lib/table/tableEditing";
-import { loadVirtualRowIdentifier } from "@/lib/table/virtualRowIdentifier";
+import { loadVirtualRowIdentifier, resolveRowIdentifierColumns } from "@/lib/table/virtualRowIdentifier";
import { createMetadataLoadTrace, logMetadataLoadTrace, MetadataLoadCoordinator, type MetadataLoadCacheStatus, type MetadataLoadTraceLogger } from "./metadataLoadCoordinator";
import { metadataScopeKey, metadataScopeParts, type MetadataScopeInput } from "./metadataLoadScope";
import { metadataCacheInvalidationMatcher, MetadataResultCache, type MetadataCacheInvalidation } from "./metadataResultCache";
@@ -321,6 +321,43 @@ export async function loadTableIndexes(request: TableMetadataRequest): Promise<I
return promise;
}
+function tableMetadataFromFacets(request: TableMetadataRequest, columnsResult: TableColumnsLoadResult, indexes: IndexInfo[], rowIdentityResolved: boolean): TableMetadata {
+ let columns = columnsResult.columns;
+ const resolveReportedSchema = (request.databaseType === "vastbase" || request.databaseType === "kingbase") && !request.schema;
+ const resolvedSchema = resolveReportedSchema ? columns.find((column) => column.resolved_schema)?.resolved_schema : request.schema;
+ let primaryKeys = editableRowIdentifierColumns(request.databaseType as DatabaseType, columns, indexes, columnsResult.tableType);
+ // UNIQUE KEY models use is_unique here; rewriting is_primary_key would also
+ // change CREATE/DDL, transfer, data generation and cached column consumers.
+ const keyColumns = uniqueKeyModelColumns(request.databaseType as DatabaseType, indexes);
+ if (keyColumns.size > 0) {
+ if (primaryKeys.length === 0) primaryKeys = columns.filter((column) => keyColumns.has(column.name.toLowerCase())).map((column) => column.name);
+ columns = columns.map((column) => (keyColumns.has(column.name.toLowerCase()) && !column.is_unique ? { ...column, is_unique: true } : column));
+ }
+ return {
+ schema: resolvedSchema || undefined,
+ tableName: request.tableName,
+ tableType: columnsResult.tableType,
+ catalog: request.catalog,
+ database: request.database,
+ databaseType: request.databaseType as DatabaseType,
+ columns,
+ indexes,
+ primaryKeys,
+ rowIdentityResolved: rowIdentityResolved && columns.length > 0,
+ cachedAt: columnsResult.cachedAt,
+ };
+}
+
+export async function loadTableMetadataForExport(request: TableMetadataRequest, read: <T>(request: () => Promise<T>) => Promise<T>, capturedVirtualPrimaryKeys: readonly string[] = []): Promise<TableMetadata> {
+ const columnsResult = await read(() => loadTableColumns({ ...request, force: true }));
+ const resolvedTarget = columnsResult.columns.find((column) => column.resolved_table);
+ const indexRequest = { ...request, force: true, schema: resolvedTarget?.resolved_schema ?? (columnsResult.schema || request.schema || request.currentSchema), tableName: resolvedTarget?.resolved_table ?? request.tableName };
+ const indexes = columnsResult.columns.length ? await read(() => loadTableIndexes(indexRequest)) : [];
+ const metadata = tableMetadataFromFacets(request, columnsResult, indexes, true);
+ const virtualPrimaryKeys = metadata.primaryKeys.length ? [] : (resolveRowIdentifierColumns(capturedVirtualPrimaryKeys, metadata.columns) ?? []);
+ return virtualPrimaryKeys.length ? { ...metadata, primaryKeys: virtualPrimaryKeys, virtualPrimaryKeys } : metadata;
+}
+
export async function loadTableMetadata(request: TableMetadataRequest): Promise<TableMetadataLoadResult> {
const scope = tableMetadataScope(request);
const trace = createMetadataLoadTrace(scope);
@@ -362,37 +399,13 @@ export async function loadTableMetadata(request: TableMetadataRequest): Promise<
};
const indexesPromise = resolveReportedSchema || resolveSynonymTarget ? undefined : loadTableIndexes(request).catch(() => undefined);
const columnsResult = await columnsPromise;
- let columns = columnsResult.columns;
+ const columns = columnsResult.columns;
const resolvedTarget = columns.find((column) => column.resolved_table);
const resolvedSchema = resolveReportedSchema ? columns.find((column) => column.resolved_schema)?.resolved_schema : request.schema;
const indexRequest = { ...request, schema: resolvedTarget?.resolved_schema ?? (resolvedSchema || request.currentSchema), tableName: resolvedTarget?.resolved_table ?? request.tableName };
const loadedIndexes = columns.length > 0 ? await ((!resolvedTarget && indexesPromise) || loadTableIndexes(indexRequest).catch(() => undefined)) : [];
const indexes = loadedIndexes ?? indexFailure();
- let primaryKeys = editableRowIdentifierColumns(request.databaseType as DatabaseType, columns, indexes, columnsResult.tableType);
- // Doris/StarRocks UNIQUE KEY columns are NULLable and never reported as
- // primary keys, yet they are the engine's key. Surface them through
- // `is_unique` only: the data generator, CREATE/DDL export, transfer and the
- // ER diagram read `is_primary_key` as a literal PRIMARY KEY, and `columns`
- // may reference the cached columns facet, so rewriting the flag would leak
- // into those paths and into every later metadata load.
- const keyColumns = uniqueKeyModelColumns(request.databaseType as DatabaseType, indexes);
- if (keyColumns.size > 0) {
- if (primaryKeys.length === 0) primaryKeys = columns.filter((column) => keyColumns.has(column.name.toLowerCase())).map((column) => column.name);
- columns = columns.map((column) => (keyColumns.has(column.name.toLowerCase()) && !column.is_unique ? { ...column, is_unique: true } : column));
- }
- return {
- schema: resolvedSchema || undefined,
- tableName: request.tableName,
- tableType: columnsResult.tableType,
- catalog: request.catalog,
- database: request.database,
- databaseType: request.databaseType as DatabaseType,
- columns,
- indexes,
- primaryKeys,
- rowIdentityResolved: rowIdentityResolved && columns.length > 0,
- cachedAt: columnsResult.cachedAt,
- };
+ return tableMetadataFromFacets(request, columnsResult, indexes, rowIdentityResolved);
},
{ force: request.force, kind: scope.kind },
);
diff --git a/apps/desktop/src/stores/__tests__/queryStore.directExportQueue.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.directExportQueue.spec.ts
new file mode 100644
index 0000000000..1245d35094
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.directExportQueue.spec.ts
@@ -0,0 +1,112 @@
+import { createPinia, disposePinia, setActivePinia, type Pinia } from "pinia";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import type { QueryResultExportRequest, TableExportProgress } from "@/lib/backend/api";
+
+const mocks = vi.hoisted(() => ({
+ mode: vi.fn(),
+ ensure: vi.fn(),
+ start: vi.fn(),
+ cancel: vi.fn(),
+ config: { id: "oracle-1", name: "Oracle", db_type: "oracle", database: "APP", query_timeout_secs: 30 },
+}));
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => true }));
+vi.mock("@/lib/export/exportExecutionMode", () => ({ showExportExecutionModeDialog: mocks.mode }));
+vi.mock("@/lib/backend/api", () => ({ saveOpenTabsState: vi.fn().mockResolvedValue(undefined), startQueryResultExport: mocks.start, cancelQueryResultExport: mocks.cancel }));
+vi.mock("@/stores/connectionStore", () => ({ useConnectionStore: () => ({ ensureConnected: mocks.ensure, getConfig: () => mocks.config, connectionIdentifierQuote: () => '"' }) }));
+vi.mock("@/stores/settingsStore", () => ({ useSettingsStore: () => ({ editorSettings: { exportBatchSize: 1000, exportRowLimitEnabled: false, globalQueryTimeoutSecs: 30 } }) }));
+
+const pending: Array<{ request: QueryResultExportRequest; progress: (progress: TableExportProgress) => void; resolve: (progress: TableExportProgress) => void; reject: (error: Error) => void }> = [];
+let pinia: Pinia;
+beforeEach(() => {
+ vi.resetModules();
+ vi.clearAllMocks();
+ pending.length = 0;
+ pinia = createPinia();
+ setActivePinia(pinia);
+ vi.stubGlobal("localStorage", { getItem: () => null, setItem() {}, removeItem() {} });
+ mocks.mode.mockResolvedValue("queued");
+ mocks.ensure.mockResolvedValue(undefined);
+ mocks.cancel.mockResolvedValue(undefined);
+ mocks.start.mockImplementation((request, progress) => new Promise((resolve, reject) => pending.push({ request, progress, resolve, reject })));
+});
+
+afterEach(() => {
+ disposePinia(pinia);
+ vi.unstubAllGlobals();
+});
+
+function finish(index: number) {
+ const entry = pending[index]!;
+ const progress: TableExportProgress = { exportId: entry.request.exportId, tableName: "Query Result", status: "Done", rowsExported: 1, totalRows: 1 };
+ entry.progress(progress);
+ entry.resolve(progress);
+}
+
+it("queues the captured direct SQL request and does not reconnect or execute waiting items", async () => {
+ const { useQueryStore } = await import("../queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("oracle-1", "APP", "Query");
+ const comments = ["original"];
+ await store.exportQuerySqlDirect(id, "SELECT 1 FROM dual", "csv", "first.csv");
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ await store.exportQuerySqlDirect(id, "SELECT 2 FROM dual", "xlsx", "second.xlsx", comments);
+ expect(mocks.ensure).toHaveBeenCalledTimes(1);
+ comments[0] = "changed";
+ store.tabs.find((tab) => tab.id === id)!.database = "OTHER";
+ finish(0);
+ await vi.waitFor(() => expect(pending).toHaveLength(2));
+ expect(pending[1]!.request).toEqual(expect.objectContaining({ database: "APP", sql: "SELECT 2 FROM dual", filePath: "second.xlsx", columnComments: ["original"] }));
+ finish(1);
+});
+
+it("cancels a waiting direct export without a cancel or start RPC", async () => {
+ const { useQueryStore } = await import("../queryStore");
+ const { useExportTracker } = await import("@/composables/useExportTracker");
+ const store = useQueryStore();
+ const id = store.createTab("oracle-1", "APP", "Query");
+ await store.exportQuerySqlDirect(id, "SELECT 1 FROM dual", "csv", "first.csv");
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ await store.exportQuerySqlDirect(id, "SELECT 2 FROM dual", "csv", "second.csv");
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[1]!.exportId);
+ finish(0);
+ await Promise.resolve();
+ expect(mocks.start).toHaveBeenCalledTimes(1);
+ expect(mocks.cancel).not.toHaveBeenCalled();
+});
+
+it("waits for actual terminal after running cancellation and retains unknown execution", async () => {
+ const { useQueryStore } = await import("../queryStore");
+ const { useExportTracker } = await import("@/composables/useExportTracker");
+ const store = useQueryStore();
+ const id = store.createTab("oracle-1", "APP", "Query");
+ await store.exportQuerySqlDirect(id, "SELECT 1 FROM dual", "csv", "first.csv");
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ await store.exportQuerySqlDirect(id, "SELECT 2 FROM dual", "csv", "second.csv");
+ const tracker = useExportTracker();
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(tracker.tasks.value[0]!.status).toBe("Cancelling");
+ await tracker.cancelTask(tracker.tasks.value[0]!.exportId);
+ expect(mocks.cancel).toHaveBeenCalledTimes(1);
+ expect(mocks.cancel).toHaveBeenCalledWith(pending[0]!.request.exportId, pending[0]!.request.executionId);
+ expect(pending).toHaveLength(1);
+ pending[0]!.reject(new Error("lost terminal"));
+ await vi.waitFor(() => expect(tracker.tasks.value[0]!.status).toBe("Unknown"));
+ expect(pending).toHaveLength(1);
+ await tracker.cancelTask(tracker.tasks.value[1]!.exportId);
+});
+
+it("finishes a known preparation failure and permits the following independent export", async () => {
+ const { useQueryStore } = await import("../queryStore");
+ const { useExportTracker } = await import("@/composables/useExportTracker");
+ const store = useQueryStore();
+ const id = store.createTab("oracle-1", "APP", "Query");
+ mocks.ensure.mockRejectedValueOnce(new Error("connection unavailable"));
+ await store.exportQuerySqlDirect(id, "SELECT 1 FROM dual", "csv", "first.csv");
+ await store.exportQuerySqlDirect(id, "SELECT 2 FROM dual", "csv", "second.csv");
+ const tracker = useExportTracker();
+ await vi.waitFor(() => expect(pending).toHaveLength(1));
+ expect(tracker.tasks.value[0]!).toEqual(expect.objectContaining({ status: "Error", errorMessage: "connection unavailable", finishedAt: expect.any(Number) }));
+ expect(pending[0]!.request.sql).toBe("SELECT 2 FROM dual");
+ finish(0);
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts
index efa9910484..2ece9e5d37 100644
--- a/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts
+++ b/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts
@@ -113,6 +113,44 @@ function structuredSqlError(detail = "duplicate key") {
}
describe("queryStore multi-statement errors", () => {
+ it.each(["single", "indexed", "ambiguous", "use", "session_setup"] as const)("retains actual legacy export provenance without guessing statement positions (%s)", async (kind) => {
+ const preview = (index?: number): QueryResult => ({
+ columns: ["ID", "BODY"],
+ rows: [[1, "preview"]],
+ column_types: ["INT", "TEXT"],
+ affected_rows: 0,
+ execution_time_ms: 0,
+ large_value_cells: [{ row_index: 0, column_index: 1, original_bytes: 5000 }],
+ ...(index === undefined ? {} : { statement_index: index }),
+ });
+ const sql =
+ kind === "single"
+ ? "SELECT ID, BODY FROM app.FIRST"
+ : kind === "indexed"
+ ? "SELECT ID, BODY FROM app.FIRST; SELECT ID, BODY FROM app.SECOND"
+ : kind === "ambiguous"
+ ? "CALL p(); SELECT ID, BODY FROM app.SECOND"
+ : kind === "use"
+ ? "USE other; SELECT ID, BODY FROM other.SECOND"
+ : "SET @v = 1; SELECT ID, BODY FROM app.SECOND";
+ const results = kind === "single" ? [preview()] : kind === "indexed" ? [preview(0), preview(1)] : kind === "ambiguous" ? [preview(), preview()] : [{ columns: [], rows: [], affected_rows: 0, execution_time_ms: 0, statement_index: 0 }, preview(1)];
+ mocks.executeMulti.mockResolvedValue(results);
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("mysql-1", "app", "Query");
+ await store.executeTabSql(id, sql);
+ const tab = store.tabs.find((item) => item.id === id)!;
+ const source = (tab.results ?? [tab.result!]).at(-1)!.legacy_export_source!;
+ expect(source).toMatchObject({ connectionId: "mysql-1", database: kind === "use" ? "other" : "app", databaseType: "mysql", ordinaryReadSafe: kind !== "ambiguous" && kind !== "session_setup" });
+ expect(source.connectionFingerprint).toMatch(/^[0-9a-f]{16}$/);
+ if (kind === "ambiguous") expect(source.statementSql).toBeUndefined();
+ else expect(source.statementSql).toContain(kind === "single" ? "app.FIRST" : kind === "use" ? "other.SECOND" : "app.SECOND");
+ tab.connectionId = "other";
+ tab.database = "private";
+ expect(source.connectionId).toBe("mysql-1");
+ expect(source.database).toBe(kind === "use" ? "other" : "app");
+ });
+
it.each([
["oracle", "BEGIN\n NULL;\n NULL;\nEND;\n/\nSELECT 3;"],
["mysql", "DELIMITER $$\nCREATE PROCEDURE p() BEGIN SELECT 1; SELECT 2; END$$\nDELIMITER ;\nSELECT 3;"],
diff --git a/apps/desktop/src/stores/__tests__/queryStore.queryResultExport.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.queryResultExport.spec.ts
index 16d8e29d8a..3d9a764cea 100644
--- a/apps/desktop/src/stores/__tests__/queryStore.queryResultExport.spec.ts
+++ b/apps/desktop/src/stores/__tests__/queryStore.queryResultExport.spec.ts
@@ -1,11 +1,17 @@
import { createPinia, setActivePinia } from "pinia";
import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { QueryResult } from "@/types/database";
+import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
const mocks = vi.hoisted(() => ({
ensureConnected: vi.fn(),
getConfig: vi.fn(),
connectionIdentifierQuote: vi.fn(),
executeMulti: vi.fn(),
+ getColumns: vi.fn(),
+ listIndexes: vi.fn(),
+ buildTableSelectSql: vi.fn(),
+ buildDataGridContextFilterCondition: vi.fn(),
prepareQueryPaginationExecutionPlan: vi.fn(),
closeClientConnectionSession: vi.fn(),
closeQuerySession: vi.fn(),
@@ -15,6 +21,10 @@ const mocks = vi.hoisted(() => ({
vi.mock("@/lib/backend/api", () => ({
saveOpenTabsState: vi.fn().mockResolvedValue(undefined),
executeMulti: mocks.executeMulti,
+ getColumns: mocks.getColumns,
+ listIndexes: mocks.listIndexes,
+ buildTableSelectSql: mocks.buildTableSelectSql,
+ buildDataGridContextFilterCondition: mocks.buildDataGridContextFilterCondition,
prepareQueryPaginationExecutionPlan: mocks.prepareQueryPaginationExecutionPlan,
closeClientConnectionSession: mocks.closeClientConnectionSession,
closeQuerySession: mocks.closeQuerySession,
@@ -25,6 +35,7 @@ vi.mock("@/stores/connectionStore", () => ({
ensureConnected: mocks.ensureConnected,
getConfig: mocks.getConfig,
connectionIdentifierQuote: mocks.connectionIdentifierQuote,
+ lookupLocalCompletionTables: () => [],
}),
}));
@@ -53,6 +64,7 @@ describe("queryStore query result export", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.exportSettings.exportRowLimitEnabled = false;
+ mocks.exportSettings.exportRowLimit = 100;
installLocalStorage();
setActivePinia(createPinia());
mocks.ensureConnected.mockResolvedValue(undefined);
@@ -62,6 +74,242 @@ describe("queryStore query result export", () => {
mocks.connectionIdentifierQuote.mockReturnValue("[");
});
+ async function legacySheetFixture() {
+ const config = { id: "oracle-1", name: "Oracle", db_type: "oracle" as const, database: "XE" };
+ mocks.getConfig.mockReturnValue(config);
+ mocks.getColumns.mockResolvedValue([
+ { name: "ID", data_type: "NUMBER", is_primary_key: true },
+ { name: "BODY", data_type: "CLOB" },
+ ]);
+ mocks.listIndexes.mockResolvedValue([{ name: "PK_ITEMS", columns: ["ID"], is_primary: true, is_unique: true }]);
+ mocks.buildDataGridContextFilterCondition.mockImplementation(async ({ columnName, value }) => `${columnName} = ${value}`);
+ mocks.buildTableSelectSql.mockResolvedValue("SELECT ID, BODY FROM HR.ITEMS WHERE ID = 7");
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("oracle-1", "XE", "Query");
+ const result: QueryResult = {
+ columns: ["KEY_ALIAS", "BODY_ALIAS"],
+ rows: [[7, "preview"]],
+ affected_rows: 0,
+ execution_time_ms: 0,
+ large_value_cells: [{ row_index: 0, column_index: 1, original_bytes: 100 }],
+ legacy_export_source: { connectionId: "oracle-1", database: "XE", schema: "HR", databaseType: "oracle", connectionFingerprint: connectionConfigFingerprint(config), statementSql: "SELECT i.ID AS KEY_ALIAS, i.BODY AS BODY_ALIAS FROM HR.ITEMS i", ordinaryReadSafe: true },
+ };
+ return { store, id, result };
+ }
+
+ it("resolves a non-active sheet from its captured table and aliases without replaying the query", async () => {
+ const { store, id, result } = await legacySheetFixture();
+ const capture = store.captureResultLegacyValuesForExport(id, result);
+ expect(capture.unavailableReason).toBeUndefined();
+ expect(mocks.getColumns).not.toHaveBeenCalled();
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.database = "OTHER";
+ tab.sql = "CALL other_procedure()";
+ result.rows[0]![0] = 99;
+ mocks.executeMulti.mockResolvedValueOnce([{ columns: ["ID", "BODY"], rows: [[7, "complete"]], affected_rows: 0, execution_time_ms: 0 }]);
+ const values = await capture.read!(new AbortController().signal);
+ expect(values.get(0)?.get(1)).toBe("complete");
+ expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ schema: "HR", tableName: "ITEMS", columns: ["ID", "BODY"], whereInput: "((ID = 7))" }));
+ expect(mocks.executeMulti).toHaveBeenCalledWith("oracle-1", "XE", "SELECT ID, BODY FROM HR.ITEMS WHERE ID = 7", undefined, expect.any(String), expect.any(Object));
+ expect(result.rows).toEqual([[99, "preview"]]);
+ });
+
+ it.each(["missing", "procedure", "expression", "setup"])("does not infer missing or unsafe legacy sheet provenance (%s)", async (kind) => {
+ const { store, id, result } = await legacySheetFixture();
+ if (kind === "missing") delete result.legacy_export_source;
+ if (kind === "procedure") result.legacy_export_source!.statementSql = "CALL fill_items()";
+ if (kind === "expression") result.legacy_export_source!.statementSql = "SELECT ID, BODY || 'suffix' AS BODY_ALIAS FROM HR.ITEMS";
+ if (kind === "setup") result.legacy_export_source!.ordinaryReadSafe = false;
+ const capture = store.captureResultLegacyValuesForExport(id, result);
+ if (capture.read) await expect(capture.read(new AbortController().signal)).rejects.toMatchObject({ status: "failed" });
+ else expect(capture.unavailableReason).toBeTruthy();
+ expect(mocks.executeMulti).not.toHaveBeenCalled();
+ });
+
+ it("does not borrow the active grid row identifier for a different sheet", async () => {
+ const { store, id, result } = await legacySheetFixture();
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.tableMeta = { tableName: "OTHER", schema: "HR", primaryKeys: ["BODY"], columns: [{ name: "BODY", data_type: "VARCHAR" }] };
+ mocks.getColumns.mockResolvedValueOnce([
+ { name: "ID", data_type: "NUMBER" },
+ { name: "BODY", data_type: "CLOB" },
+ ]);
+ mocks.listIndexes.mockResolvedValueOnce([]);
+ await expect(store.captureResultLegacyValuesForExport(id, result).read!(new AbortController().signal)).rejects.toMatchObject({ status: "failed" });
+ expect(mocks.executeMulti).not.toHaveBeenCalled();
+ expect(tab.tableMeta.tableName).toBe("OTHER");
+ });
+
+ it.each(["success", "transport"])("waits for the actual metadata reply after cancellation (%s)", async (outcome) => {
+ const { store, id, result } = await legacySheetFixture();
+ let resolve!: (value: unknown[]) => void;
+ let reject!: (error: Error) => void;
+ mocks.getColumns.mockImplementationOnce(
+ () =>
+ new Promise((yes, no) => {
+ resolve = yes;
+ reject = no;
+ }),
+ );
+ const controller = new AbortController();
+ const pending = store.captureResultLegacyValuesForExport(id, result).read!(controller.signal).catch((error) => error);
+ await vi.waitFor(() => expect(mocks.getColumns).toHaveBeenCalledOnce());
+ controller.abort();
+ let settled = false;
+ void pending.then(() => {
+ settled = true;
+ });
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ expect(mocks.listIndexes).not.toHaveBeenCalled();
+ if (outcome === "transport") reject(new Error("metadata reply lost"));
+ else resolve([]);
+ expect(await pending).toMatchObject({ status: outcome === "transport" ? "unknown" : "cancelled" });
+ expect(mocks.listIndexes).not.toHaveBeenCalled();
+ expect(mocks.executeMulti).not.toHaveBeenCalled();
+ });
+
+ it("captures SQL, location and export settings before a queued request starts", async () => {
+ mocks.exportSettings.exportRowLimitEnabled = true;
+ mocks.exportSettings.exportRowLimit = 100;
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("kingbase-1", "original", "Query");
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.lastExecutedSql = "SELECT id FROM original_items";
+ tab.result = { columns: ["id"], rows: [[1]], execution_time_ms: 0, affected_rows: 0 };
+ const build = store.captureQueryResultExportRequest(id, true)!;
+ tab.lastExecutedSql = "SELECT secret FROM other_items";
+ tab.database = "other";
+ mocks.exportSettings.exportRowLimit = 9;
+ store.tabs.splice(store.tabs.indexOf(tab), 1);
+
+ const request = await build({ exportId: "queued", filePath: "original.csv", format: "csv" });
+ expect(request).toEqual(expect.objectContaining({ connectionId: "kingbase-1", database: "original", sql: "SELECT id FROM original_items", rowLimit: 100 }));
+ });
+
+ it("rejects a queued request when the connection identity changes during reconnect", async () => {
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("kingbase-1", "app", "Query");
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.lastExecutedSql = "SELECT id FROM items";
+ tab.result = { columns: ["id"], rows: [[1]], execution_time_ms: 0, affected_rows: 0 };
+ const build = store.captureQueryResultExportRequest(id, true)!;
+ mocks.ensureConnected.mockImplementationOnce(async () => {
+ mocks.getConfig.mockReturnValue({ id: "kingbase-1", name: "Kingbase", db_type: "kingbase", host: "different-target" });
+ });
+ await expect(build({ exportId: "queued", filePath: "original.csv", format: "csv" })).rejects.toThrow((await import("@/i18n")).default.global.t("exportProgress.connectionChanged"));
+ });
+
+ it("captures fallback pagination and waits for its independent session to close", async () => {
+ mocks.prepareQueryPaginationExecutionPlan.mockImplementation(async (request) => ({ sqlToExecute: request.sql, pageLimit: 2, pageOffset: 0, useAgentResultSession: false }));
+ mocks.executeMulti.mockResolvedValue([{ columns: ["id"], rows: [[1]], execution_time_ms: 0, affected_rows: 0 }]);
+ let close!: () => void;
+ mocks.closeClientConnectionSession.mockImplementationOnce(
+ () =>
+ new Promise<void>((resolve) => {
+ close = resolve;
+ }),
+ );
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("kingbase-1", "original", "Query");
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.lastExecutedSql = "SELECT id FROM original_items";
+ tab.result = { columns: ["id"], rows: [[0]], has_more: true, execution_time_ms: 0, affected_rows: 0 };
+ const fetch = store.captureTabResultForExport(id)!;
+ tab.lastExecutedSql = "SELECT secret FROM other_items";
+ tab.database = "other";
+ let settled = false;
+ const result = fetch().then((value) => {
+ settled = true;
+ return value;
+ });
+ await vi.waitFor(() => expect(mocks.closeClientConnectionSession).toHaveBeenCalledOnce());
+ expect(settled).toBe(false);
+ expect(mocks.executeMulti).toHaveBeenCalledWith("kingbase-1", "original", "SELECT id FROM original_items", undefined, expect.any(String), expect.objectContaining({ clientSessionId: expect.stringContaining(`${id}:export:`) }));
+ close();
+ expect((await result)?.rows).toEqual([[1]]);
+ });
+
+ it.each(["success", "transport", "cursor_cleanup"] as const)("keeps captured export cancellation behind the actual read and cleanup (%s)", async (completion) => {
+ mocks.prepareQueryPaginationExecutionPlan.mockResolvedValue({ sqlToExecute: "SELECT id FROM items", pageLimit: 1, pageOffset: 0, useAgentResultSession: true });
+ let resolveRead!: (value: unknown) => void;
+ let rejectRead!: (error: Error) => void;
+ mocks.executeMulti.mockImplementationOnce(
+ () =>
+ new Promise((resolve, reject) => {
+ resolveRead = resolve;
+ rejectRead = reject;
+ }),
+ );
+ if (completion === "cursor_cleanup") mocks.closeQuerySession.mockRejectedValueOnce(new Error("cursor close lost"));
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("kingbase-1", "app", "Query");
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.lastExecutedSql = "SELECT id FROM items";
+ tab.result = { columns: ["id"], rows: [[0]], has_more: true, execution_time_ms: 0, affected_rows: 0 };
+ const controller = new AbortController();
+ const pending = store.captureTabResultForExport(id)!(undefined, { signal: controller.signal }).catch((error) => error);
+ await vi.waitFor(() => expect(mocks.executeMulti).toHaveBeenCalledOnce());
+ let settled = false;
+ void pending.then(() => {
+ settled = true;
+ });
+ controller.abort();
+ await Promise.resolve();
+ expect(settled).toBe(false);
+ expect(mocks.closeClientConnectionSession).not.toHaveBeenCalled();
+ if (completion === "transport") rejectRead(new Error("read transport lost"));
+ else resolveRead([{ columns: ["id"], rows: [[1]], has_more: true, session_id: "owned-cursor", execution_time_ms: 0, affected_rows: 0 }]);
+ expect(await pending).toMatchObject({ status: completion === "success" ? "cancelled" : "unknown" });
+ expect(mocks.executeMulti).toHaveBeenCalledOnce();
+ expect(mocks.executeMulti.mock.calls[0]![5]).toMatchObject({ deferLobs: false });
+ expect(mocks.closeClientConnectionSession).toHaveBeenCalledOnce();
+ if (completion !== "transport") expect(mocks.closeQuerySession).toHaveBeenCalledWith("kingbase-1", "app", "owned-cursor", expect.any(String), undefined);
+ });
+
+ it.each(["preview", "unknown_error", "not_started"] as const)("does not return incomplete captured export data (%s)", async (reason) => {
+ mocks.prepareQueryPaginationExecutionPlan.mockResolvedValue({ sqlToExecute: "SELECT id FROM items", pageLimit: 2, pageOffset: 0, useAgentResultSession: false });
+ mocks.executeMulti.mockResolvedValueOnce([
+ {
+ columns: ["id"],
+ rows: [["preview"]],
+ execution_time_ms: 0,
+ affected_rows: 0,
+ ...(reason === "preview"
+ ? { large_value_cells: [{ row_index: 0, column_index: 0, original_bytes: 5000 }] }
+ : { execution_error: true, error: { version: 1, code: "DBX-JDBC-4001", messageKey: "backendErrors.jdbc.sqlFailed", messageParams: {}, operationOutcome: reason === "not_started" ? "not_started" : "unknown" } }),
+ },
+ ]);
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("kingbase-1", "app", "Query");
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.lastExecutedSql = "SELECT id FROM items";
+ tab.result = { columns: ["id"], rows: [[0]], has_more: true, execution_time_ms: 0, affected_rows: 0 };
+ await expect(store.captureTabResultForExport(id)!()).rejects.toMatchObject({ status: reason === "unknown_error" ? "unknown" : "failed" });
+ expect(mocks.closeClientConnectionSession).toHaveBeenCalledOnce();
+ });
+
+ it.each(["ending", "lost", "unknown"] as const)("rejects a queued request whose transaction is %s", async (status) => {
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ const id = store.createTab("kingbase-1", "app", "Query");
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.lastExecutedSql = "SELECT id FROM items";
+ tab.result = { columns: ["id"], rows: [[1]], execution_time_ms: 0, affected_rows: 0 };
+ tab.autoCommit = false;
+ tab.txnSessionId = "original-transaction";
+ const build = store.captureQueryResultExportRequest(id, true)!;
+ tab.txnStatus = status;
+ await expect(build({ exportId: "queued", filePath: "original.csv", format: "csv" })).rejects.toThrow((await import("@/i18n")).default.global.t("exportProgress.transactionUnavailable"));
+ expect(mocks.ensureConnected).not.toHaveBeenCalled();
+ });
+
it.each([99, 100, 101])("probes a result of %i rows without a cached total", async (count) => {
mocks.exportSettings.exportRowLimitEnabled = true;
mocks.getConfig.mockReturnValue({ id: "mysql-1", db_type: "mysql", database: "app" });
diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts
index 1884087dab..50a730c46e 100644
--- a/apps/desktop/src/stores/queryStore.ts
+++ b/apps/desktop/src/stores/queryStore.ts
@@ -1,5 +1,6 @@
import { hasShortDataGridSqlPage } from "@/lib/dataGrid/dataGridPagination";
import { createQueryRequestTiming } from "@/lib/queryRequestTiming";
+import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
import { executeCursorOffsetPage } from "@/lib/query/queryCursorOffsetPagination";
import { mergeQueryMessages, queryResultMessages } from "@/lib/query/queryResultMessages";
import { appendNeo4jNodeCells, extractNeo4jNodeCells } from "@/lib/neo4j/neo4jNodeResult";
@@ -92,9 +93,12 @@ import { repairRestoredDataTabTableIdentity, tableMetaForDataTab } from "@/lib/t
import { isDataTabMetadataLifecycleStale } from "@/lib/sidebar/dataTabOpenPolicy";
import type { SqlInsertMode } from "@/lib/export/sqlInsertMode";
import { csvNullLiteralForMode } from "@/lib/export/csvNullMode";
+import { SnapshotCompletionError, type ExportReadControl } from "@/lib/export/snapshotCompletion";
import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
import { formatMetadataColumnTypeLabel } from "@/lib/dataGrid/dataGridColumnType";
-import { getCachedTableMetadata, loadTableColumns, loadTableIndexes, loadTableMetadata, tableMetadataToDataTabMeta, updateCachedTableMetadataType, type TableMetadataRequest } from "@/lib/metadata/tableMetadataCache";
+import { getCachedTableMetadata, loadTableColumns, loadTableIndexes, loadTableMetadata, loadTableMetadataForExport, tableMetadataToDataTabMeta, updateCachedTableMetadataType, type TableMetadataRequest } from "@/lib/metadata/tableMetadataCache";
+import { resolveCapturedLegacyLargeValueCells, type CapturedLegacyLargeValueExport } from "@/lib/dataGrid/legacyLargeValueExport";
+import { loadVirtualRowIdentifier } from "@/lib/table/virtualRowIdentifier";
import { loadObjectDdl } from "@/lib/metadata/objectDdlCache";
import { MetadataTaskLimiter } from "@/lib/metadata/metadataTaskLimiter";
import { formatDdlForDisplay } from "@/lib/sql/ddlDisplay";
@@ -147,6 +151,7 @@ import { useConnectionStore } from "@/stores/connectionStore";
import { useSettingsStore } from "@/stores/settingsStore";
import { useSavedSqlStore } from "@/stores/savedSqlStore";
import { useExportTracker } from "@/composables/useExportTracker";
+import { showExportExecutionModeDialog } from "@/lib/export/exportExecutionMode";
import { recordQueryCancellationLatency, resourceLifecycleDiagnostics } from "@/lib/diagnostics/resourceLifecycleDiagnostics";
import { appendDebugLog } from "@/lib/backend/debugLog";
import { BackendErrorException, formatError, isManualTransactionSessionExpired, isUnsupportedManualTransactionMethod, normalizeBackendError, type BackendError } from "@/lib/backend/errorUtils";
@@ -1895,9 +1900,10 @@ export const useQueryStore = defineStore("query", () => {
}
}
- async function closeClientSessionId(connectionId: string, database: string, clientSessionId: string, catalog: string | undefined, logContext: Record<string, unknown> = {}, throwOnError = false) {
+ async function closeClientSessionId(connectionId: string, database: string, clientSessionId: string, catalog: string | undefined, logContext: Record<string, unknown> = {}, throwOnError = false, reportCompletion = false) {
try {
- if (catalog) await api.closeClientConnectionSession(connectionId, database, clientSessionId, catalog);
+ if (reportCompletion && isTauriRuntime()) await api.closeClientConnectionSession(connectionId, database, clientSessionId, catalog, true);
+ else if (catalog) await api.closeClientConnectionSession(connectionId, database, clientSessionId, catalog);
else await api.closeClientConnectionSession(connectionId, database, clientSessionId);
} catch (error) {
console.warn("[DBX][client-session:close:error]", { ...logContext, clientSessionId, error });
@@ -9128,8 +9134,51 @@ export const useQueryStore = defineStore("query", () => {
const sourceLabelDatabase = targetDatabase || conn?.database;
const executionClientSessionId = options?.pagination?.clientSessionId ?? (tab.mode === "query" || tab.mode === "data" ? tabClientSessionId(tab) : undefined);
const deferLobs = conn?.db_type === "jdbc" && (tab.mode === "query" || tab.mode === "data");
+ const legacyExportSource = conn
+ ? {
+ connectionId: executionConnectionId,
+ database: executionDatabase,
+ schema: executionSchema,
+ catalog: executionCatalog,
+ databaseType: effectiveDbType,
+ connectionFingerprint: connectionConfigFingerprint(conn),
+ identifierQuote: connStore.connectionIdentifierQuote?.(executionConnectionId),
+ serverVersion: conn.database_info?.productVersion,
+ hiddenPrimaryKeys: hiddenPrimaryKeys.map((projection) => ({ ...projection })),
+ }
+ : undefined;
+ const exportExecutionSql = sqlToExecute;
+ const exportSourceSql = queryMetadataSql;
const bindLargeValueContext = (results: QueryResult[], txnSessionId?: string): QueryResult[] => {
+ const needsLegacySource = results.some((result) => result.large_value_cells?.some((cell) => !cell.value_ref));
+ const exportExecutedStatements = needsLegacySource ? splitSqlStatementRanges(exportExecutionSql, effectiveDbType, sqlStatementParameterOptions) : [];
+ const exportSourceStatements = needsLegacySource ? splitSqlStatementRanges(exportSourceSql, effectiveDbType, sqlStatementParameterOptions) : [];
for (const result of results) {
+ if (legacyExportSource && result.large_value_cells?.some((cell) => !cell.value_ref)) {
+ const index = result.statement_index === undefined ? (exportExecutedStatements.length === 1 ? 0 : undefined) : Number.isInteger(result.statement_index) && result.statement_index >= 0 ? result.statement_index : undefined;
+ let database = legacyExportSource.database;
+ let ordinaryReadSafe = index !== undefined && index < exportExecutedStatements.length;
+ for (let previous = 0; ordinaryReadSafe && previous < index!; previous++) {
+ const preceding = results.filter((entry) => entry.statement_index === previous);
+ if (!preceding.length) {
+ ordinaryReadSafe = false;
+ break;
+ }
+ if (preceding.some((entry) => entry.execution_error)) {
+ ordinaryReadSafe = preceding.every((entry) => entry.error?.operationOutcome === "not_started");
+ continue;
+ }
+ const statement = exportExecutedStatements[previous]!.sql;
+ const useDatabase = useDatabaseFromStatement(statement, effectiveDbType);
+ if (useDatabase !== undefined) database = useDatabase;
+ else {
+ const assessment = classifySqlRisk(statement, { dialect: effectiveDbType });
+ ordinaryReadSafe = assessment.risk === "read" && ["select", "with"].includes(assessment.statements[0]?.firstKeyword ?? "");
+ }
+ }
+ const statements = exportSourceStatements.length === exportExecutedStatements.length ? exportSourceStatements : exportExecutedStatements;
+ result.legacy_export_source = { ...legacyExportSource, database, statementSql: index === undefined ? undefined : statements[index]?.sql, ordinaryReadSafe };
+ }
if (!result.large_value_cells?.some((cell) => cell.value_ref)) continue;
result.large_value_refs = result.large_value_cells.flatMap((cell) => (cell.value_ref ? [cell.value_ref] : []));
result.large_value_context = {
@@ -10357,6 +10406,102 @@ export const useQueryStore = defineStore("query", () => {
}
}
+ function captureResultLegacyValuesForExport(id: string, result: QueryResult): CapturedLegacyLargeValueExport {
+ const unavailableReason = "Original table source is unavailable; execute a qualified single-table SELECT with its row identifier";
+ const tab = findExecutionTab(id);
+ const source = result.legacy_export_source ? cloneTabDraft(result.legacy_export_source) : undefined;
+ if (!tab || !source?.ordinaryReadSafe || !source.statementSql || !source.databaseType || !["mysql", "postgres", "oracle", "db2"].includes(source.databaseType)) return { unavailableReason };
+ const connStore = useConnectionStore();
+ const current = connStore.getConfig(source.connectionId);
+ if (!current || connectionConfigFingerprint(current) !== source.connectionFingerprint || effectiveDatabaseTypeForConnection(current) !== source.databaseType) return { unavailableReason: i18n.global.t("exportProgress.connectionChanged") };
+ const connection = cloneTabDraft(current);
+ const snapshot = cloneTabDraft(result);
+ const editability = analyzeEditableQueryEditability(source.statementSql);
+ if (!editability.editable || !editability.analysis) return { unavailableReason };
+ const analysis = editability.analysis;
+ const sources = editableQuerySources(analysis);
+ if (sources.length !== 1 || analysis.distinct || analysis.groupByColumns?.length || analysis.hasHavingClause || hasUnparsedQuerySource(source.statementSql)) return { unavailableReason };
+ const parsedSource = sources[0]!;
+ if (source.databaseType !== "mysql" && !parsedSource.schema && !source.schema) return { unavailableReason };
+ const context: QueryTab = { ...tab, connectionId: source.connectionId, database: source.database, schema: source.schema, catalog: source.catalog, mode: "query", tableMeta: undefined, queryAnalysis: undefined, querySourceColumns: undefined, queryWriteTargets: undefined, result: snapshot };
+ const target = resolveEditableSourceMetadataTarget(context, analysis, parsedSource, connection, source.databaseType, source.database);
+ const existing =
+ tab.result === result &&
+ tab.connectionId === source.connectionId &&
+ tab.database === source.database &&
+ tab.tableMeta?.tableName === target.request.tableName &&
+ (tab.tableMeta.database ?? source.database) === target.request.database &&
+ normalizeOptionalSchema(tab.tableMeta.schema) === normalizeOptionalSchema(target.request.schema) &&
+ tab.tableMeta.catalog === target.request.catalog
+ ? cloneTabDraft(tab.tableMeta)
+ : undefined;
+ const virtualColumns = analysis.selectStar ? snapshot.columns.map((name) => ({ name })) : analysis.columns.flatMap((column) => (column.sourceName ? [{ name: column.sourceName }] : []));
+ const virtualPrimaryKeys = loadVirtualRowIdentifier(target.request, virtualColumns);
+ const settings = { ...settingsStore.editorSettings };
+ const rowIdUnsupported = rowIdLocatorUnsupported(source.connectionId);
+ const cells = snapshot.large_value_cells?.filter((cell) => !cell.value_ref) ?? [];
+ return {
+ read: async (signal) => {
+ const check = () => {
+ if (signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ const current = connStore.getConfig(source.connectionId);
+ if (!current || connectionConfigFingerprint(current) !== source.connectionFingerprint) throw new SnapshotCompletionError("failed", i18n.global.t("exportProgress.connectionChanged"));
+ };
+ const read = async <T>(request: () => Promise<T>): Promise<T> => {
+ check();
+ let value: T;
+ try {
+ value = await request();
+ } catch (error) {
+ throw new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ }
+ check();
+ return value;
+ };
+ try {
+ check();
+ const loaded = existing ? { tableMeta: existing, source: target.source, analysis: target.analysis } : loadedEditableSourceFromMetadata(target, await loadTableMetadataForExport(target.request, read, virtualPrimaryKeys));
+ if (loaded.tableMeta.tableType?.toUpperCase().includes("TEMP") || loaded.tableMeta.tableType?.toUpperCase().includes("VIEW")) throw new Error(unavailableReason);
+ const metadataAnalysis = expandStarProjectionColumnsForSource(bindColumnsForSource(source.databaseType!, loaded.analysis, loaded.source, loaded.tableMeta.columns), loaded.source, loaded.tableMeta.columns);
+ const hidden = source.hiddenPrimaryKeys ?? [];
+ const synthetic = hidden.find((projection) => projection.sourceName.toUpperCase() === DBX_ROWID_COLUMN);
+ const primaryKeys = loaded.tableMeta.primaryKeys.length === 0 && synthetic ? [DBX_ROWID_COLUMN] : loaded.tableMeta.primaryKeys;
+ const sourceColumns = sourceColumnsForResult(metadataAnalysis, snapshot.columns, loaded.source.key, source.databaseType, primaryKeys);
+ if (!sourceColumns) throw new Error(unavailableReason);
+ for (const projection of hidden) {
+ const index = snapshot.columns.findIndex((column) => column === projection.alias);
+ if (index >= 0) sourceColumns[index] = projection.sourceName;
+ }
+ const keyIndexes = primaryKeys.map((key) => sourceColumns.findIndex((column) => column === key));
+ if (!primaryKeys.length || keyIndexes.some((index) => index < 0) || cells.some((cell) => keyIndexes.includes(cell.column_index) || !sourceColumns[cell.column_index])) throw new Error(unavailableReason);
+ const requests = cells.map((cell) => ({ rowId: cell.row_index, sourceIndex: cell.row_index, columnIndex: cell.column_index, originalBytes: cell.original_bytes }));
+ return await resolveCapturedLegacyLargeValueCells(
+ {
+ databaseType: source.databaseType,
+ connectionId: source.connectionId,
+ executionDatabase: source.database,
+ tableMeta: { ...loaded.tableMeta, primaryKeys },
+ sourceColumns: sourceColumns.map((column) => column ?? ""),
+ rows: snapshot.rows,
+ identifierQuote: source.identifierQuote,
+ serverVersion: source.serverVersion,
+ includeDatabaseName: settings.generateSqlIncludeDatabaseName,
+ includeRowId: shouldIncludeSyntheticRowId(source.databaseType, primaryKeys, loaded.tableMeta.tableType) && !rowIdUnsupported,
+ timeoutSecs: queryTimeoutSecsForConnection(connection, settings.globalQueryTimeoutSecs),
+ },
+ requests,
+ signal,
+ { uuid, translate: (key) => i18n.global.t(key), translateBackendError: (error) => translateBackendError(i18n.global.t, error) },
+ check,
+ );
+ } catch (error) {
+ if (error instanceof SnapshotCompletionError) throw error;
+ throw new SnapshotCompletionError("failed", error instanceof Error ? error.message : String(error));
+ }
+ },
+ };
+ }
+
async function resolveResultMetadataForBatch(id: string, result: QueryResult): Promise<QueryMetadataPatch | undefined> {
const tab = findExecutionTab(id);
if (!tab || !result.sourceStatement) return undefined;
@@ -10701,10 +10846,110 @@ export const useQueryStore = defineStore("query", () => {
async function fetchTabResultForExport(id: string, onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void, probeRowLimit = false): Promise<QueryResult | undefined> {
const tab = tabs.value.find((t) => t.id === id);
if (!tab?.result) return undefined;
+ return fetchCapturedTabResultForExport(tab, onProgress, probeRowLimit);
+ }
+
+ function captureTabResultForExport(id: string) {
+ const source = tabs.value.find((tab) => tab.id === id);
+ if (!source?.result) return undefined;
+ const tab: QueryTab = {
+ ...source,
+ result: cloneTabDraft(source.result),
+ tableMeta: source.tableMeta ? cloneTabDraft(source.tableMeta) : undefined,
+ queryAnalysis: source.queryAnalysis ? cloneTabDraft(source.queryAnalysis) : undefined,
+ };
+ const location = { ...queryResultExecutionLocation(source) };
+ const settings = { ...settingsStore.editorSettings };
+ const connStore = useConnectionStore();
+ const config = connStore.getConfig(location.connectionId);
+ const fingerprint = config ? connectionConfigFingerprint(config) : undefined;
+ const txnSessionId = exportTxnSessionId(source);
+ const transactionEpoch = manualTransactionTargetEpoch(source);
+ const capture = {
+ location,
+ settings,
+ clientSessionId: `${tabClientSessionId(tab, "export")}:${uuid()}`,
+ assertCurrent() {
+ const current = connStore.getConfig(location.connectionId);
+ if (!current || connectionConfigFingerprint(current) !== fingerprint) throw new Error(i18n.global.t("exportProgress.connectionChanged"));
+ if (
+ txnSessionId &&
+ (tabs.value.find((item) => item.id === id) !== source ||
+ exportTxnSessionId(source) !== txnSessionId ||
+ manualTransactionTargetEpoch(source) !== transactionEpoch ||
+ pendingManualTransactionCommits.has(source) ||
+ pendingSqlServerTransactionEnds.has(id) ||
+ source.txnStatus === "lost" ||
+ source.txnStatus === "unknown" ||
+ source.txnStatus === "ending")
+ )
+ throw new Error(i18n.global.t("exportProgress.transactionUnavailable"));
+ },
+ };
+ return async (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void, control?: ExportReadControl) => {
+ try {
+ return await fetchCapturedTabResultForExport(tab, onProgress, false, { ...capture, control });
+ } catch (error) {
+ if (error instanceof SnapshotCompletionError) throw error;
+ throw new SnapshotCompletionError("failed", error instanceof Error ? error.message : String(error));
+ }
+ };
+ }
+
+ async function fetchCapturedTabResultForExport(
+ tab: QueryTab,
+ onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void,
+ probeRowLimit = false,
+ capture?: { location: ReturnType<typeof queryResultExecutionLocation>; settings: typeof settingsStore.editorSettings; clientSessionId: string; assertCurrent: () => void; control?: ExportReadControl },
+ ): Promise<QueryResult | undefined> {
+ if (!tab.result) return undefined;
+ const settings = capture?.settings ?? settingsStore.editorSettings;
+ let unknownError: SnapshotCompletionError | undefined;
+ const check = () => {
+ if (unknownError) throw unknownError;
+ if (capture?.control?.signal.aborted) throw new SnapshotCompletionError("cancelled", "Export cancelled");
+ capture?.assertCurrent();
+ };
+ const read = async <T>(request: () => Promise<T>): Promise<T> => {
+ check();
+ try {
+ return await request();
+ } catch (error) {
+ if (!capture) throw error;
+ unknownError = new SnapshotCompletionError("unknown", error instanceof Error ? error.message : String(error));
+ throw unknownError;
+ }
+ };
+ const validateResult = (result: QueryResult) => {
+ if (!capture) return;
+ if (result.execution_error) {
+ const error = new SnapshotCompletionError(result.error?.operationOutcome === "not_started" ? "failed" : "unknown", result.error ? translateBackendError(i18n.global.t, result.error) : String(result.rows?.[0]?.[0] ?? "Export query failed"));
+ if (error.status === "unknown") unknownError = error;
+ throw error;
+ }
+ if (result.large_value_cells?.length || result.server_message) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ };
+ const closeCapturedResources = async (closeCursor: () => Promise<void>, closeClient: () => Promise<void>) => {
+ let cleanupError: unknown;
+ try {
+ await closeCursor();
+ } catch (error) {
+ cleanupError = error;
+ }
+ try {
+ await closeClient();
+ } catch (error) {
+ cleanupError ??= error;
+ }
+ if (unknownError) throw unknownError;
+ if (cleanupError) throw new SnapshotCompletionError("unknown", cleanupError instanceof Error ? cleanupError.message : String(cleanupError));
+ };
+ check();
if (tab.mode === "data") {
const connStore = useConnectionStore();
await connStore.ensureConnected(tab.connectionId);
+ check();
const conn = connStore.getConfig(tab.connectionId);
const tableMeta = tableMetaForDataTab(tab);
if (!tableMeta?.tableName) return tab.result;
@@ -10718,19 +10963,21 @@ export const useQueryStore = defineStore("query", () => {
const primaryKeys = tab.tableMeta ? tab.tableMeta.primaryKeys : tableMeta.primaryKeys;
const sortOrder = tab.resultSortColumn && tab.resultSortDirection ? `${quoteTableDataIdentifier(effectiveDbType, tab.resultSortColumn, identifierQuote)} ${tab.resultSortDirection.toUpperCase()}` : undefined;
const orderBy = combineDataGridOrderByInputs(tab.orderByInput, tab.structuredOrderByInput) || sortOrder;
- const queryTimeoutSecs = queryTimeoutSecsForConnection(conn, settingsStore.editorSettings.globalQueryTimeoutSecs);
+ const queryTimeoutSecs = queryTimeoutSecsForConnection(conn, settings.globalQueryTimeoutSecs);
const executionDatabase = tab.database;
const rows: QueryResult["rows"] = [];
let columns: string[] = [];
+ let columnTypes: string[] | undefined;
let executionTimeMs = 0;
let offset = 0;
- const clientSessionId = tabClientSessionId(tab, "export");
+ const clientSessionId = capture?.clientSessionId ?? tabClientSessionId(tab, "export");
const exportExecutionId = uuid();
const useAgentCursor = usesAgentCursorForTableData(conn?.db_type, conn?.driver_profile);
let sessionId: string | undefined;
try {
while (true) {
+ check();
const sql = await api.buildTableSelectSql({
databaseType: effectiveDbType,
driverProfile: conn?.driver_profile,
@@ -10748,36 +10995,48 @@ export const useQueryStore = defineStore("query", () => {
limit: pageLimit,
offset,
});
- const results = await api.executeMulti(
- tab.connectionId,
- executionDatabase,
- sql,
- undefined,
- exportExecutionId,
- useAgentCursor
- ? {
- maxRows: 2_147_483_647,
- fetchSize: pageLimit,
- pageSize: pageLimit,
- resultSessionId: sessionId,
- clientSessionId,
- catalog: tableMeta.catalog,
- timeoutSecs: queryTimeoutSecs,
- }
- : {
- maxRows: pageLimit,
- fetchSize: pageLimit,
- clientSessionId,
- catalog: tableMeta.catalog,
- timeoutSecs: queryTimeoutSecs,
- },
+ const results = await read(() =>
+ api.executeMulti(
+ tab.connectionId,
+ executionDatabase,
+ sql,
+ undefined,
+ exportExecutionId,
+ useAgentCursor
+ ? {
+ maxRows: 2_147_483_647,
+ fetchSize: pageLimit,
+ pageSize: pageLimit,
+ resultSessionId: sessionId,
+ clientSessionId,
+ catalog: tableMeta.catalog,
+ timeoutSecs: queryTimeoutSecs,
+ ...(capture ? { deferLobs: false } : {}),
+ }
+ : {
+ maxRows: pageLimit,
+ fetchSize: pageLimit,
+ clientSessionId,
+ catalog: tableMeta.catalog,
+ timeoutSecs: queryTimeoutSecs,
+ ...(capture ? { deferLobs: false } : {}),
+ },
+ ),
);
const result = results[0];
if (!result) {
- if (useAgentCursor) throw new Error("Missing cursor result during table export");
+ if (useAgentCursor || capture) throw new Error("Missing cursor result during table export");
break;
}
const nextSessionId = result.session_id?.trim() || undefined;
+ if (capture) {
+ sessionId = nextSessionId ?? sessionId;
+ results.forEach(validateResult);
+ check();
+ if (columns.length && (columns.length !== result.columns.length || columns.some((column, index) => column !== result.columns[index]))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ if (result.truncated || (useAgentCursor && (typeof result.has_more !== "boolean" || (result.has_more && result.rows.length === 0)))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ columnTypes ??= result.column_types;
+ }
if (useAgentCursor) {
sessionId = nextSessionId ?? sessionId;
if (conn?.db_type === "cassandra" && (result.truncated || typeof result.has_more !== "boolean")) throw new Error("Incomplete cursor result during table export");
@@ -10793,17 +11052,27 @@ export const useQueryStore = defineStore("query", () => {
offset += result.rows.length;
}
} finally {
- try {
- if (sessionId) await api.closeQuerySession(tab.connectionId, executionDatabase, sessionId, clientSessionId, tableMeta.catalog);
- } catch (error) {
- queryExecutionLog("warn", "table-export-session-close:error", { sessionId, error });
- } finally {
- await closeClientSessionId(tab.connectionId, executionDatabase, clientSessionId, tableMeta.catalog, { tabId: tab.id });
+ if (capture) {
+ await closeCapturedResources(
+ async () => {
+ if (sessionId) await api.closeQuerySession(tab.connectionId, executionDatabase, sessionId, clientSessionId, tableMeta.catalog);
+ },
+ () => closeClientSessionId(tab.connectionId, executionDatabase, clientSessionId, tableMeta.catalog, { tabId: tab.id }, true, true),
+ );
+ } else {
+ try {
+ if (sessionId) await api.closeQuerySession(tab.connectionId, executionDatabase, sessionId, clientSessionId, tableMeta.catalog);
+ } catch (error) {
+ queryExecutionLog("warn", "table-export-session-close:error", { sessionId, error });
+ } finally {
+ await closeClientSessionId(tab.connectionId, executionDatabase, clientSessionId, tableMeta.catalog, { tabId: tab.id }, capture !== undefined);
+ }
}
}
return {
columns: columns.length ? columns : tab.result.columns,
+ ...(capture ? { column_types: columnTypes ?? tab.result.column_types } : {}),
rows,
affected_rows: 0,
execution_time_ms: executionTimeMs,
@@ -10862,7 +11131,7 @@ export const useQueryStore = defineStore("query", () => {
const cachedResultForExport = (): QueryResult => {
// A last page (has_more=false) is not a complete result. Nor is a LOB
// preview safe to write as if it were the underlying value.
- if (probeRowLimit && !sourceSnapshotComplete) {
+ if ((probeRowLimit || capture) && !sourceSnapshotComplete) {
throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
}
return resultForTransfer(sourceResult);
@@ -10870,7 +11139,7 @@ export const useQueryStore = defineStore("query", () => {
// Reuse a result explicitly known to be complete. Re-executing it on the
// export session can lose temporary tables, session settings or uncommitted
// values, and would no longer transfer the snapshot shown to the user.
- if (probeRowLimit && sourceSnapshotComplete) return resultForTransfer(sourceResult);
+ if ((probeRowLimit || capture) && sourceSnapshotComplete) return resultForTransfer(sourceResult);
// A separate execution cannot see this transaction's uncommitted values.
// Keep its writes and cursor untouched; only a fully loaded snapshot is
// safe to transfer without re-entering the manual transaction protocol.
@@ -10881,9 +11150,10 @@ export const useQueryStore = defineStore("query", () => {
const baseSql = queryResultBaseSql(tab);
if (!sql.trim()) return cachedResultForExport();
- const location = queryResultExecutionLocation(tab);
+ const location = capture?.location ?? queryResultExecutionLocation(tab);
const connStore = useConnectionStore();
await connStore.ensureConnected(location.connectionId);
+ check();
const conn = connStore.getConfig(location.connectionId);
const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
const executableSql = effectiveDbType === "mysql" ? stripMysqlClientDisplayCommand(sql) : sql;
@@ -10897,10 +11167,10 @@ export const useQueryStore = defineStore("query", () => {
const executionDatabase = location.database;
// main 引入全局查询超时:queryTimeoutSecsForConnection 现需传入全局默认值;
// settingsStore 取 defineStore 顶层声明的实例(本函数无局部覆盖)。
- const queryTimeoutSecs = queryTimeoutSecsForConnection(conn, settingsStore.editorSettings.globalQueryTimeoutSecs);
+ const queryTimeoutSecs = queryTimeoutSecsForConnection(conn, settings.globalQueryTimeoutSecs);
const useAgentCursor = usesAgentCursorForQuery(conn?.db_type, conn?.driver_profile);
const queryBaseSql = effectiveDbType === "mysql" ? stripMysqlClientDisplayCommand(baseSql) : baseSql;
- const exportSettings = useSettingsStore().editorSettings;
+ const exportSettings = settings;
// Database transfers read one extra row to distinguish a complete result at
// the limit from a partial export, without relying on a cached COUNT.
const exportRowLimit = exportSettings.exportRowLimitEnabled ? exportSettings.exportRowLimit + (probeRowLimit ? 1 : 0) : Number.POSITIVE_INFINITY;
@@ -10938,7 +11208,8 @@ export const useQueryStore = defineStore("query", () => {
if (!plan) throw new Error(QUERY_RESULT_EXPORT_UNSUPPORTED_ERROR);
if (plan.requestLimit === 0) break;
- const result = await api.mongoFindDocuments(location.connectionId, exportDatabase, mongoCommand.collection, plan.requestSkip, plan.requestLimit, mongoCommand.filter, mongoCommand.projection, mongoCommand.sort, mongoCommand.collation, exportExecutionId);
+ const result = await read(() => api.mongoFindDocuments(location.connectionId, exportDatabase, mongoCommand.collection, plan.requestSkip, plan.requestLimit, mongoCommand.filter, mongoCommand.projection, mongoCommand.sort, mongoCommand.collation, exportExecutionId));
+ check();
const pageDocuments = result.documents.slice(0, plan.requestLimit);
documents.push(...pageDocuments);
@@ -10988,12 +11259,13 @@ export const useQueryStore = defineStore("query", () => {
// A database transfer must retain session-local tables and settings. The
// file-export path owns a separate client session; this path borrows the
// source session and must not close it when exporting finishes.
- const clientSessionId = probeRowLimit ? sourceClientSessionId : tabClientSessionId(tab, "export");
+ const clientSessionId = probeRowLimit ? sourceClientSessionId : (capture?.clientSessionId ?? tabClientSessionId(tab, "export"));
const exportExecutionId = uuid();
let incomplete = false;
try {
while (rows.length < exportRowLimit) {
+ check();
const remaining = exportRowLimit - rows.length;
const effectivePageLimit = Math.min(pageLimit, remaining);
const plan = await api.prepareQueryPaginationExecutionPlan({
@@ -11005,7 +11277,7 @@ export const useQueryStore = defineStore("query", () => {
firstPageUsesActualSql: true,
executionHint: effectiveDbType === "gaussdb" ? gaussdbCountQueryDopHint(conn) : undefined,
});
- if (probeRowLimit && plan.paginationError) throw new Error(plan.paginationError);
+ if ((probeRowLimit || capture) && plan.paginationError) throw new Error(plan.paginationError);
if (typeof plan.pageLimit !== "number" || typeof plan.pageOffset !== "number") return cachedResultForExport();
const executionOptions = plan.useAgentResultSession
? {
@@ -11016,11 +11288,12 @@ export const useQueryStore = defineStore("query", () => {
clientSessionId,
catalog: location.catalog,
timeoutSecs: queryTimeoutSecs,
+ ...(capture ? { deferLobs: false } : {}),
}
- : { maxRows: plan.pageLimit, fetchSize: plan.pageLimit, clientSessionId, catalog: location.catalog, timeoutSecs: queryTimeoutSecs };
- const results = await api.executeMulti(location.connectionId, executionDatabase, plan.sqlToExecute, location.schema, exportExecutionId, executionOptions);
+ : { maxRows: plan.pageLimit, fetchSize: plan.pageLimit, clientSessionId, catalog: location.catalog, timeoutSecs: queryTimeoutSecs, ...(capture ? { deferLobs: false } : {}) };
+ const results = await read(() => api.executeMulti(location.connectionId, executionDatabase, plan.sqlToExecute, location.schema, exportExecutionId, executionOptions));
if (!results[0]) {
- if (probeRowLimit) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ if (probeRowLimit || capture) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
break;
}
const result = stripPaginationRowNumber(results[0], plan.paginationRowNumberColumn);
@@ -11029,11 +11302,13 @@ export const useQueryStore = defineStore("query", () => {
// closing the borrowed source client session.
const nextSessionId = result.session_id?.trim() || sessionId;
sessionId = nextSessionId;
+ results.forEach(validateResult);
+ check();
if (probeRowLimit && (result.execution_error || result.server_message || result.large_value_cells?.length)) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
- if (probeRowLimit && columns.length > 0 && (result.columns.length !== columns.length || result.columns.some((column, index) => column !== columns[index]))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
- if (probeRowLimit && columnTypes.length > 0 && result.column_types?.length && (columnTypes.length !== result.column_types.length || result.column_types.some((type, index) => type !== columnTypes[index]))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
- if (probeRowLimit && plan.useAgentResultSession && (typeof result.has_more !== "boolean" || (result.has_more && (!nextSessionId || result.rows.length === 0)))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
- if (probeRowLimit && result.has_more && result.rows.length === 0) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ if ((probeRowLimit || capture) && columns.length > 0 && (result.columns.length !== columns.length || result.columns.some((column, index) => column !== columns[index]))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ if ((probeRowLimit || capture) && columnTypes.length > 0 && result.column_types?.length && (columnTypes.length !== result.column_types.length || result.column_types.some((type, index) => type !== columnTypes[index]))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ if ((probeRowLimit || capture) && plan.useAgentResultSession && (typeof result.has_more !== "boolean" || (result.has_more && (!nextSessionId || result.rows.length === 0)))) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
+ if ((probeRowLimit || capture) && result.has_more && result.rows.length === 0) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
// `has_more` only describes the current page. It is expected to be true
// for every page except the last one, so it must not be accumulated as
// an incomplete-export marker.
@@ -11048,15 +11323,28 @@ export const useQueryStore = defineStore("query", () => {
offset += result.rows.length;
}
} finally {
- try {
- if (sessionId) await api.closeQuerySession(location.connectionId, location.database, sessionId, clientSessionId, location.catalog);
- } catch (error) {
- queryExecutionLog("warn", "query-export-session-close:error", { sessionId, error });
- } finally {
- if (!probeRowLimit) void closeClientSessionId(location.connectionId, location.database, clientSessionId, location.catalog, { tabId: tab.id });
+ if (capture) {
+ await closeCapturedResources(
+ async () => {
+ if (sessionId) await api.closeQuerySession(location.connectionId, location.database, sessionId, clientSessionId, location.catalog);
+ },
+ () => closeClientSessionId(location.connectionId, location.database, clientSessionId, location.catalog, { tabId: tab.id }, true, true),
+ );
+ } else {
+ try {
+ if (sessionId) await api.closeQuerySession(location.connectionId, location.database, sessionId, clientSessionId, location.catalog);
+ } catch (error) {
+ queryExecutionLog("warn", "query-export-session-close:error", { sessionId, error });
+ } finally {
+ if (!probeRowLimit) {
+ const closing = closeClientSessionId(location.connectionId, location.database, clientSessionId, location.catalog, { tabId: tab.id }, capture !== undefined);
+ if (capture) await closing;
+ }
+ }
}
}
+ if (capture && incomplete) throw new Error(i18n.global.t("grid.exportDatabaseIncomplete"));
return resultForTransfer({
columns: columns.length ? columns : sourceResult.columns,
column_types: columnTypes.length ? columnTypes : sourceResult.column_types,
@@ -11068,78 +11356,116 @@ export const useQueryStore = defineStore("query", () => {
});
}
- async function buildQueryResultExportRequest(id: string, options: BuildQueryResultExportRequestOptions) {
- const tab = tabs.value.find((t) => t.id === id);
- if (!tab?.result || tab.mode !== "query") return undefined;
+ function captureQueryResultExportRequest(id: string, queued = false) {
+ const source = tabs.value.find((t) => t.id === id);
+ if (!source?.result || source.mode !== "query") return undefined;
+ const tab = source;
+ const sourceResult = source.result;
const sql = queryResultExecutionSql(tab);
if (!sql.trim()) return undefined;
const location = queryResultExecutionLocation(tab);
const connStore = useConnectionStore();
- await connStore.ensureConnected(location.connectionId);
- const conn = connStore.getConfig(location.connectionId);
- const settings = useSettingsStore().editorSettings;
- const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
- if (!effectiveDbType) return undefined;
- if (effectiveDbType === "mongodb") return undefined;
- const useAgentCursor = usesAgentCursorForQuery(conn?.db_type, conn?.driver_profile);
- const executableSql = effectiveDbType === "mysql" ? stripMysqlClientDisplayCommand(sql) : sql;
- const queryBaseSql = effectiveDbType === "mysql" ? stripMysqlClientDisplayCommand(queryResultBaseSql(tab)) : queryResultBaseSql(tab);
- const resultStatementIndex = tab.result.statement_index;
+ const originalConfig = connStore.getConfig(location.connectionId);
+ const fingerprint = originalConfig ? connectionConfigFingerprint(originalConfig) : undefined;
+ const settings = { ...useSettingsStore().editorSettings };
+ const baseSql = queryResultBaseSql(tab);
+ const resultStatementIndex = sourceResult.statement_index;
const batchSql = tab.resultBaseSql ?? tab.lastExecutedSql ?? tab.sql;
- // The export runs on its own session, so replay earlier statements of the batch: PostgreSQL
- // temp tables, MySQL user variables (#13111). The backend keeps only side-effect-free ones.
- const replaysBatchSetup = effectiveDbType === "postgres" || effectiveDbType === "mysql";
- const batchStatements = replaysBatchSetup && tab.result.truncated === true && Number.isInteger(resultStatementIndex) && resultStatementIndex! > 0 ? splitSqlStatementRanges(batchSql, effectiveDbType) : [];
- const setupSql = batchStatements[resultStatementIndex!]?.sql === tab.result.sourceStatement ? batchStatements.slice(0, resultStatementIndex).map((statement) => statement.sql) : undefined;
- const rowLimit = settings.exportRowLimitEnabled ? settings.exportRowLimit : null;
- const totalRows = typeof tab.resultTotalRowCount === "number" ? (rowLimit === null ? tab.resultTotalRowCount : Math.min(tab.resultTotalRowCount, rowLimit)) : null;
- const clientSessionId = `${tabClientSessionId(tab, "export")}:${options.exportId}`;
+ const sourceStatement = sourceResult.sourceStatement;
+ const truncated = sourceResult.truncated;
+ const sourceTotalRows = tab.resultTotalRowCount;
+ const sourceClientSessionId = tabClientSessionId(tab, "export");
+ const txnSessionId = exportTxnSessionId(tab);
+ const transactionEpoch = manualTransactionTargetEpoch(tab);
const hasUniqueInsertTarget = tab.tableMeta !== undefined && tab.queryAnalysis?.multiSource !== true && (tab.queryAnalysis?.sources?.length ?? 1) === 1 && (tab.queryWriteTargets?.length ?? 1) <= 1;
- return {
- exportId: options.exportId,
- connectionId: location.connectionId,
- database: location.database,
- schema: location.schema,
- catalog: location.catalog,
- sql: executableSql,
- queryBaseSql,
- setupSql,
- databaseType: effectiveDbType,
- useAgentCursor,
- filePath: options.filePath,
- format: options.format,
- ...(options.format === "sql" && options.insertMode ? { insertMode: options.insertMode } : {}),
- includeSqlSheet: options.format === "xlsx" && options.includeSqlSheet === true,
- pageSize: settings.exportBatchSize,
- rowLimit,
- totalRows,
- timeoutSecs: queryTimeoutSecsForConnection(conn, settingsStore.editorSettings.globalQueryTimeoutSecs),
- keysetOptimizationEnabled: settings.queryExportKeysetOptimizationEnabled,
- csvQuoteMode: settings.csvQuoteMode,
- clientSessionId,
- txnSessionId: exportTxnSessionId(tab),
- nullLiteral: csvNullLiteralForMode(settings.csvNullMode),
- executionId: uuid(),
- exportTableName: options.format === "sql" && hasUniqueInsertTarget ? options.exportTableName : undefined,
- exportSchema: options.format === "sql" && hasUniqueInsertTarget && options.exportTableName ? options.exportSchema : undefined,
- exportColumnTypes: options.exportColumnTypes,
- exportColumnExtras: options.exportColumnExtras,
- numericColumnRightAlign: settings.numericColumnRightAlign,
- identifierQuote: connStore.connectionIdentifierQuote(location.connectionId),
+ function assertSourceAvailable() {
+ const config = connStore.getConfig(location.connectionId);
+ if (!config || fingerprint !== connectionConfigFingerprint(config)) throw new Error(i18n.global.t("exportProgress.connectionChanged"));
+ if (
+ txnSessionId &&
+ (tabs.value.find((item) => item.id === id) !== tab ||
+ exportTxnSessionId(tab) !== txnSessionId ||
+ manualTransactionTargetEpoch(tab) !== transactionEpoch ||
+ pendingManualTransactionCommits.has(tab) ||
+ pendingSqlServerTransactionEnds.has(id) ||
+ tab.txnStatus === "lost" ||
+ tab.txnStatus === "unknown" ||
+ tab.txnStatus === "ending")
+ )
+ throw new Error(i18n.global.t("exportProgress.transactionUnavailable"));
+ }
+
+ return async (options: BuildQueryResultExportRequestOptions) => {
+ if (queued) assertSourceAvailable();
+ await connStore.ensureConnected(location.connectionId);
+ if (queued) assertSourceAvailable();
+ const conn = connStore.getConfig(location.connectionId);
+ const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
+ if (!effectiveDbType) return undefined;
+ if (effectiveDbType === "mongodb") return undefined;
+ const useAgentCursor = usesAgentCursorForQuery(conn?.db_type, conn?.driver_profile);
+ const executableSql = effectiveDbType === "mysql" ? stripMysqlClientDisplayCommand(sql) : sql;
+ const queryBaseSql = effectiveDbType === "mysql" ? stripMysqlClientDisplayCommand(baseSql) : baseSql;
+ // The export runs on its own session, so replay earlier statements of the batch: PostgreSQL
+ // temp tables, MySQL user variables (#13111). The backend keeps only side-effect-free ones.
+ const replaysBatchSetup = effectiveDbType === "postgres" || effectiveDbType === "mysql";
+ const batchStatements = replaysBatchSetup && truncated === true && Number.isInteger(resultStatementIndex) && resultStatementIndex! > 0 ? splitSqlStatementRanges(batchSql, effectiveDbType) : [];
+ const setupSql = batchStatements[resultStatementIndex!]?.sql === sourceStatement ? batchStatements.slice(0, resultStatementIndex).map((statement) => statement.sql) : undefined;
+ const rowLimit = settings.exportRowLimitEnabled ? settings.exportRowLimit : null;
+ const totalRows = typeof sourceTotalRows === "number" ? (rowLimit === null ? sourceTotalRows : Math.min(sourceTotalRows, rowLimit)) : null;
+ const clientSessionId = `${sourceClientSessionId}:${options.exportId}`;
+
+ return {
+ exportId: options.exportId,
+ connectionId: location.connectionId,
+ database: location.database,
+ schema: location.schema,
+ catalog: location.catalog,
+ sql: executableSql,
+ queryBaseSql,
+ setupSql,
+ databaseType: effectiveDbType,
+ useAgentCursor,
+ filePath: options.filePath,
+ format: options.format,
+ ...(options.format === "sql" && options.insertMode ? { insertMode: options.insertMode } : {}),
+ includeSqlSheet: options.format === "xlsx" && options.includeSqlSheet === true,
+ pageSize: settings.exportBatchSize,
+ rowLimit,
+ totalRows,
+ timeoutSecs: queryTimeoutSecsForConnection(conn, settings.globalQueryTimeoutSecs),
+ keysetOptimizationEnabled: settings.queryExportKeysetOptimizationEnabled,
+ csvQuoteMode: settings.csvQuoteMode,
+ clientSessionId,
+ txnSessionId,
+ nullLiteral: csvNullLiteralForMode(settings.csvNullMode),
+ executionId: uuid(),
+ exportTableName: options.format === "sql" && hasUniqueInsertTarget ? options.exportTableName : undefined,
+ exportSchema: options.format === "sql" && hasUniqueInsertTarget && options.exportTableName ? options.exportSchema : undefined,
+ exportColumnTypes: options.exportColumnTypes,
+ exportColumnExtras: options.exportColumnExtras,
+ numericColumnRightAlign: settings.numericColumnRightAlign,
+ identifierQuote: connStore.connectionIdentifierQuote(location.connectionId),
+ };
};
}
+ async function buildQueryResultExportRequest(id: string, options: BuildQueryResultExportRequestOptions) {
+ return captureQueryResultExportRequest(id)?.(options);
+ }
+
async function exportQuerySqlDirect(id: string, sql: string, format: "csv" | "xlsx" | "txt", filePath: string, columnComments?: (string | null)[]) {
- const tab = tabs.value.find((item) => item.id === id);
- if (!tab || tab.mode !== "query" || !sql.trim()) return;
+ const source = tabs.value.find((item) => item.id === id);
+ if (!source || source.mode !== "query" || !sql.trim()) return;
+ const tab = source;
const connStore = useConnectionStore();
- await connStore.ensureConnected(tab.connectionId);
const conn = connStore.getConfig(tab.connectionId);
- const settings = useSettingsStore().editorSettings;
+ const fingerprint = conn ? connectionConfigFingerprint(conn) : undefined;
+ const settings = { ...useSettingsStore().editorSettings };
const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
if (!effectiveDbType) return;
@@ -11167,12 +11493,80 @@ export const useQueryStore = defineStore("query", () => {
nullLiteral: csvNullLiteralForMode(settings.csvNullMode),
executionId: uuid(),
numericColumnRightAlign: settings.numericColumnRightAlign,
- columnComments,
+ columnComments: columnComments ? [...columnComments] : undefined,
identifierQuote: connStore.connectionIdentifierQuote(tab.connectionId),
};
+ const transactionEpoch = manualTransactionTargetEpoch(tab);
+ const mode = await showExportExecutionModeDialog();
+ if (mode === null) return;
+
+ function assertQueuedSourceAvailable() {
+ if (mode !== "queued") return;
+ const currentConfig = connStore.getConfig(request.connectionId);
+ if (!currentConfig || connectionConfigFingerprint(currentConfig) !== fingerprint) throw new Error(i18n.global.t("exportProgress.connectionChanged"));
+ if (
+ request.txnSessionId &&
+ (tabs.value.find((item) => item.id === id) !== tab ||
+ exportTxnSessionId(tab) !== request.txnSessionId ||
+ manualTransactionTargetEpoch(tab) !== transactionEpoch ||
+ pendingManualTransactionCommits.has(tab) ||
+ pendingSqlServerTransactionEnds.has(id) ||
+ tab.txnStatus === "lost" ||
+ tab.txnStatus === "unknown" ||
+ tab.txnStatus === "ending")
+ )
+ throw new Error(i18n.global.t("exportProgress.transactionUnavailable"));
+ }
+
const tracker = useExportTracker();
- tracker.addTask("Query Result", format, filePath, request.exportId);
+ if (!isTauriRuntime()) await connStore.ensureConnected(request.connectionId);
+ const task = tracker.addTask("Query Result", format, filePath, request.exportId);
+ if (isTauriRuntime()) {
+ tracker.submitExportTask(task, mode, async () => {
+ let invoked = false;
+ let terminal = false;
+ let cancelled = false;
+ tracker.registerTaskCancelHandler(request.exportId, async () => {
+ cancelled = true;
+ task.status = "Cancelling";
+ if (invoked) await api.cancelQueryResultExport(request.exportId, request.executionId);
+ });
+ try {
+ assertQueuedSourceAvailable();
+ await connStore.ensureConnected(request.connectionId);
+ assertQueuedSourceAvailable();
+ if (cancelled) {
+ tracker.updateTableExportTask(request.exportId, { exportId: request.exportId, tableName: "Query Result", rowsExported: 0, totalRows: null, status: "Cancelled" });
+ return "settled";
+ }
+ invoked = true;
+ const result = await api.startQueryResultExport(
+ request,
+ (progress) => {
+ terminal ||= progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled";
+ tracker.updateTableExportTask(request.exportId, progress);
+ },
+ true,
+ );
+ terminal ||= result.status === "Done" || result.status === "Error" || result.status === "Cancelled";
+ tracker.updateTableExportTask(request.exportId, result);
+ return terminal ? "settled" : "unknown";
+ } catch (error) {
+ task.errorMessage = error instanceof Error ? error.message : String(error);
+ if (error instanceof SnapshotCompletionError && error.status === "failed") invoked = false;
+ if (!invoked || terminal) {
+ if (!terminal) tracker.updateTableExportTask(request.exportId, { exportId: request.exportId, tableName: "Query Result", rowsExported: 0, totalRows: null, status: "Error", errorMessage: task.errorMessage });
+ return "settled";
+ }
+ return "unknown";
+ } finally {
+ if (!invoked || terminal) tracker.unregisterTaskCancelHandler(request.exportId);
+ }
+ });
+ return;
+ }
+
tracker.registerTaskCancelHandler(request.exportId, () => api.cancelQueryResultExport(request.exportId, request.executionId));
void (async () => {
@@ -11379,6 +11773,7 @@ export const useQueryStore = defineStore("query", () => {
clearQueryResults,
setActiveResultIndex,
resolveResultMetadataForBatch,
+ captureResultLegacyValuesForExport,
executeCurrentTab,
executeCurrentSql,
executeTabSql,
@@ -11398,8 +11793,10 @@ export const useQueryStore = defineStore("query", () => {
exportResultArchive,
importResultArchive,
fetchTabResultForExport,
+ captureTabResultForExport,
countTabResultRows,
buildQueryResultExportRequest,
+ captureQueryResultExportRequest,
exportQuerySqlDirect,
applyQueryMetadataPatch,
getResourceLifecycleDiagnostics: () => resourceLifecycleDiagnostics(tabs.value),
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 786845254f..f473fbfb99 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -1842,6 +1842,20 @@ export interface QueryResult {
large_value_context?: { connectionId: string; database: string; clientSessionId?: string; txnSessionId?: string; catalog?: string };
/** Retained result refs also cover cells already hydrated into complete local values. */
large_value_refs?: string[];
+ /** Frontend-only dispatch identity; absent on results without captured provenance. */
+ legacy_export_source?: {
+ connectionId: string;
+ database: string;
+ schema?: string;
+ catalog?: string;
+ databaseType?: DatabaseType;
+ connectionFingerprint: string;
+ identifierQuote?: string;
+ serverVersion?: string;
+ statementSql?: string;
+ hiddenPrimaryKeys?: Array<{ sourceName: string; alias: string }>;
+ ordinaryReadSafe: boolean;
+ };
session_id?: string | null;
/** Frontend-only owner of a manual transaction's result cursor, including retained runs. */
manual_transaction_session_id?: string;
diff --git a/crates/dbx-core/src/connection/mod.rs b/crates/dbx-core/src/connection/mod.rs
index 72c64c3266..c4e7967660 100644
--- a/crates/dbx-core/src/connection/mod.rs
+++ b/crates/dbx-core/src/connection/mod.rs
@@ -5272,6 +5272,24 @@ impl AppState {
Ok(true)
}
+ pub async fn close_client_session_pool_with_completion(
+ &self,
+ connection_id: &str,
+ database: Option<&str>,
+ client_session_id: &str,
+ ) -> Result<bool, String> {
+ let Some((_, pool)) = self
+ .take_client_session_pool(connection_id, database, client_session_id, AgentSessionRole::Workload)
+ .await?
+ else {
+ return Ok(false);
+ };
+ tokio::time::timeout(Duration::from_secs(POOL_CLOSE_TIMEOUT_SECS), close_pool_kind_with_completion(pool))
+ .await
+ .map_err(|_| "Export session close completion was not confirmed".to_string())??;
+ Ok(true)
+ }
+
pub(crate) async fn close_metadata_session_pool(
&self,
connection_id: &str,
@@ -7468,9 +7486,20 @@ fn clone_pool_kind(pool: &PoolKind) -> PoolKind {
}
async fn close_pool_kind(pool: PoolKind) -> Result<(), String> {
+ close_pool_kind_inner(pool, false).await
+}
+
+async fn close_pool_kind_with_completion(pool: PoolKind) -> Result<(), String> {
+ close_pool_kind_inner(pool, true).await
+}
+
+async fn close_pool_kind_inner(pool: PoolKind, report_completion: bool) -> Result<(), String> {
match pool {
PoolKind::Mysql(p, _) => {
- let _ = p.disconnect().await;
+ let result = p.disconnect().await;
+ if report_completion {
+ result.map_err(|error| error.to_string())?;
+ }
}
PoolKind::Postgres(p) => p.close(),
PoolKind::Sqlite(pool) => {
@@ -7542,6 +7571,9 @@ async fn close_pool_kind(pool: PoolKind) -> Result<(), String> {
}
PoolKind::PluginConnection(handle) => {
if let Err(error) = handle.disconnect().await {
+ if report_completion {
+ return Err(error.to_string());
+ }
log::warn!(
"Failed to disconnect plugin connection '{}' ({}/{}): {error}",
handle.connection_id,
@@ -12188,6 +12220,84 @@ for line in sys.stdin:
let _ = std::fs::remove_dir_all(dir);
}
+ #[tokio::test]
+ async fn export_session_close_reports_failure_without_replacing_shared_transaction_runtime() {
+ let (state, dir) = test_app_state().await;
+ let (runtime, export_client, manual_client) = replace_runtime_on_error_clients(&dir, "close_session").await;
+ let mut config = mysql_config(Some("analytics"));
+ config.id = "conn".to_string();
+ config.db_type = DatabaseType::Dameng;
+ state.configs.write().await.insert(config.id.clone(), config);
+ let export_key = "conn:analytics:session:export-test";
+ let manual_key = "conn:analytics:session:manual-txn-test";
+ {
+ let mut pools = state.connections.write().await;
+ pools.insert(export_key.to_string(), PoolKind::Agent(export_client));
+ pools.insert(manual_key.to_string(), PoolKind::Agent(manual_client));
+ }
+ let error = state
+ .close_client_session_pool_with_completion("conn", Some("analytics"), "export-test")
+ .await
+ .unwrap_err();
+ assert!(error.contains("resource limit"), "{error}");
+ assert!(state.connections.read().await.contains_key(manual_key));
+ assert!(!runtime.is_failed());
+ state.shutdown(Duration::from_secs(1)).await;
+ let _ = std::fs::remove_dir_all(dir);
+ }
+
+ #[tokio::test]
+ async fn export_core_entries_report_the_first_pool_close_failure() {
+ for table_export in [true, false] {
+ let (state, dir) = test_app_state().await;
+ let (runtime, export_client, manual_client) = replace_runtime_on_error_clients(&dir, "close_session").await;
+ let mut config = mysql_config(Some("analytics"));
+ config.id = "conn".to_string();
+ config.db_type = DatabaseType::Dameng;
+ state.configs.write().await.insert(config.id.clone(), config);
+ let session = if table_export { "table-export:close-test" } else { "query-export:close-test" };
+ let export_key = super::session_scoped_pool_key("conn:analytics".to_string(), Some(session));
+ let manual_key = "conn:analytics:session:manual-txn-test";
+ {
+ let mut pools = state.connections.write().await;
+ pools.insert(export_key.clone(), PoolKind::Agent(export_client));
+ pools.insert(manual_key.to_string(), PoolKind::Agent(manual_client));
+ }
+ let file_path = dir.join("missing-parent").join("export.csv").to_string_lossy().into_owned();
+ let completion = if table_export {
+ let request = serde_json::from_value(serde_json::json!({
+ "exportId": "close-test", "connectionId": "conn", "database": "analytics",
+ "tableName": "T", "filePath": file_path, "format": "csv", "columns": ["ID"],
+ "columnTypes": [null], "primaryKeys": [], "skipCount": true,
+ }))
+ .unwrap();
+ crate::table_export::export_table_data_core_with_completion(&state, &request, |_| {}).await
+ } else {
+ let request = serde_json::from_value(serde_json::json!({
+ "exportId": "close-test", "connectionId": "conn", "database": "analytics",
+ "sql": "SELECT 1", "queryBaseSql": "SELECT 1", "databaseType": "dameng",
+ "filePath": file_path, "format": "unsupported", "pageSize": 100,
+ "clientSessionId": session,
+ }))
+ .unwrap();
+ crate::query_result_export::export_query_result_core_with_completion(&state, &request, None, |_| {})
+ .await
+ };
+ assert!(completion.result.is_err());
+ let error = completion.cleanup.expect_err(if table_export {
+ "table cleanup must fail"
+ } else {
+ "query cleanup must fail"
+ });
+ assert!(error.contains("resource limit"), "table={table_export}: {error}");
+ assert!(!state.connections.read().await.contains_key(&export_key));
+ assert!(state.connections.read().await.contains_key(manual_key));
+ assert!(!runtime.is_failed());
+ state.shutdown(Duration::from_secs(1)).await;
+ let _ = std::fs::remove_dir_all(dir);
+ }
+ }
+
#[tokio::test]
async fn legacy_sqlserver_metadata_close_finds_role_isolated_pool() {
let (state, dir) = test_app_state().await;
diff --git a/crates/dbx-core/src/data/duckdb_export.rs b/crates/dbx-core/src/data/duckdb_export.rs
index fcf2dc24c7..292951e62d 100644
--- a/crates/dbx-core/src/data/duckdb_export.rs
+++ b/crates/dbx-core/src/data/duckdb_export.rs
@@ -207,14 +207,19 @@ impl DuckDbExportSnapshot {
}
pub(super) async fn close(self, state: &AppState) {
+ let table = self.table.clone();
+ if let Err(error) = self.close_with_completion(state).await {
+ log::error!("Failed to remove DuckDB export snapshot table {table}: {error}");
+ }
+ }
+
+ pub(super) async fn close_with_completion(self, state: &AppState) -> Result<(), String> {
// Cleanup must not inherit a cancelled execution id. The qualified name
// can only refer to this export's temporary table.
if self.pool_key.is_none() {
- return;
+ return Ok(());
}
let sql = format!("DROP TABLE IF EXISTS {}", self.qualified_table());
- if let Err(error) = self.execute_temporary_ddl(state, &sql, None, TemporaryDdlPolicy::Cleanup).await {
- log::error!("Failed to remove DuckDB export snapshot table {}: {error}", self.table);
- }
+ self.execute_temporary_ddl(state, &sql, None, TemporaryDdlPolicy::Cleanup).await
}
}
diff --git a/crates/dbx-core/src/data/mongodb_import_export.rs b/crates/dbx-core/src/data/mongodb_import_export.rs
index 941e8ee2d6..64af848e75 100644
--- a/crates/dbx-core/src/data/mongodb_import_export.rs
+++ b/crates/dbx-core/src/data/mongodb_import_export.rs
@@ -2365,11 +2365,75 @@ fn export_progress(
}
}
+#[derive(Default)]
+struct MongoExportEvidence {
+ unknown: std::sync::atomic::AtomicBool,
+ cancelled: std::sync::atomic::AtomicBool,
+}
+
+impl MongoExportEvidence {
+ fn unknown(&self) {
+ self.unknown.store(true, std::sync::atomic::Ordering::Relaxed);
+ }
+ fn cancelled(&self) {
+ self.cancelled.store(true, std::sync::atomic::Ordering::Relaxed);
+ }
+}
+
+#[derive(Serialize)]
+#[serde(tag = "status", rename_all = "lowercase")]
+pub enum MongoExportOutcome {
+ Succeeded { value: MongoExportSummary },
+ Failed { message: String },
+ Cancelled { message: String },
+ Unknown { message: String },
+}
+
+pub async fn export_mongodb_query_reported<C, F>(
+ state: &AppState,
+ request: &MongoExportRequest,
+ is_cancelled: C,
+ on_progress: F,
+) -> MongoExportOutcome
+where
+ C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
+ F: FnMut(MongoExportProgress),
+{
+ let evidence = MongoExportEvidence::default();
+ let result = export_mongodb_query_inner(state, request, is_cancelled, on_progress, Some(&evidence)).await;
+ if evidence.unknown.load(std::sync::atomic::Ordering::Relaxed) {
+ return MongoExportOutcome::Unknown {
+ message: result.err().unwrap_or_else(|| "MongoDB export cleanup was not confirmed".into()),
+ };
+ }
+ match result {
+ Ok(value) => MongoExportOutcome::Succeeded { value },
+ Err(message) if evidence.cancelled.load(std::sync::atomic::Ordering::Relaxed) => {
+ MongoExportOutcome::Cancelled { message }
+ }
+ Err(message) => MongoExportOutcome::Failed { message },
+ }
+}
+
pub async fn export_mongodb_query_core<C, F>(
+ state: &AppState,
+ request: &MongoExportRequest,
+ is_cancelled: C,
+ on_progress: F,
+) -> Result<MongoExportSummary, String>
+where
+ C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
+ F: FnMut(MongoExportProgress),
+{
+ export_mongodb_query_inner(state, request, is_cancelled, on_progress, None).await
+}
+
+async fn export_mongodb_query_inner<C, F>(
state: &AppState,
request: &MongoExportRequest,
mut is_cancelled: C,
mut on_progress: F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<MongoExportSummary, String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
@@ -2381,6 +2445,9 @@ where
return Err("Gzip compression is only supported for BSON dump exports".to_string());
}
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
on_progress(export_progress(
&request.export_id,
MongoExportStatus::Cancelled,
@@ -2399,7 +2466,10 @@ where
_ => return Err("Not a MongoDB connection".to_string()),
}
- let total_documents = count_export_documents(state, request).await;
+ let total_documents = count_export_documents(state, request, evidence).await;
+ if evidence.is_some_and(|evidence| evidence.unknown.load(std::sync::atomic::Ordering::Relaxed)) {
+ return Err("MongoDB export count completion was not confirmed".into());
+ }
let target = PathBuf::from(&request.file_path);
if let Some(parent) = target.parent() {
@@ -2410,20 +2480,53 @@ where
let result = match request.format {
MongoExportFormat::Ndjson => {
- export_ndjson(state, request, &temp, total_documents, started_at, &mut is_cancelled, &mut on_progress).await
+ export_ndjson(
+ state,
+ request,
+ &temp,
+ total_documents,
+ started_at,
+ &mut is_cancelled,
+ &mut on_progress,
+ evidence,
+ )
+ .await
}
MongoExportFormat::Csv => {
- export_csv(state, request, &temp, total_documents, started_at, &mut is_cancelled, &mut on_progress).await
+ export_csv(
+ state,
+ request,
+ &temp,
+ total_documents,
+ started_at,
+ &mut is_cancelled,
+ &mut on_progress,
+ evidence,
+ )
+ .await
}
MongoExportFormat::Bson => {
- export_bson(state, request, &temp, total_documents, started_at, &mut is_cancelled, &mut on_progress).await
+ export_bson(
+ state,
+ request,
+ &temp,
+ total_documents,
+ started_at,
+ &mut is_cancelled,
+ &mut on_progress,
+ evidence,
+ )
+ .await
}
};
match result {
Ok((documents_read, _bytes_written)) => {
if is_cancelled(&request.export_id).await {
- cleanup_temp(&temp);
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
+ cleanup_export_temp(&temp, evidence)?;
on_progress(export_progress(
&request.export_id,
MongoExportStatus::Cancelled,
@@ -2435,7 +2538,16 @@ where
));
return Err("Export cancelled".to_string());
}
- atomic_rename(&temp, &target)?;
+ if evidence.is_some_and(|evidence| evidence.unknown.load(std::sync::atomic::Ordering::Relaxed)) {
+ cleanup_export_temp(&temp, evidence)?;
+ return Err("MongoDB export completion was not confirmed".into());
+ }
+ if let Err(error) = atomic_rename(&temp, &target) {
+ return match cleanup_export_temp(&temp, evidence) {
+ Ok(()) => Err(error),
+ Err(cleanup) => Err(format!("{error}; {cleanup}")),
+ };
+ }
on_progress(export_progress(
&request.export_id,
MongoExportStatus::Done,
@@ -2453,7 +2565,9 @@ where
})
}
Err(error) => {
- cleanup_temp(&temp);
+ if let Err(cleanup) = cleanup_export_temp(&temp, evidence) {
+ return Err(format!("{error}; {cleanup}"));
+ }
let cancelled = error == "Export cancelled" || is_cancelled(&request.export_id).await;
on_progress(export_progress(
&request.export_id,
@@ -2469,21 +2583,42 @@ where
}
}
-async fn count_export_documents(state: &AppState, request: &MongoExportRequest) -> Option<u64> {
+fn cleanup_export_temp(path: &Path, evidence: Option<&MongoExportEvidence>) -> Result<(), String> {
+ if let Some(evidence) = evidence {
+ match std::fs::remove_file(path) {
+ Ok(()) => Ok(()),
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
+ Err(error) => {
+ evidence.unknown();
+ Err(format!("MongoDB export temp cleanup failed: {error}"))
+ }
+ }
+ } else {
+ cleanup_temp(path);
+ Ok(())
+ }
+}
+
+async fn count_export_documents(
+ state: &AppState,
+ request: &MongoExportRequest,
+ evidence: Option<&MongoExportEvidence>,
+) -> Option<u64> {
if request.filter.as_deref().is_some_and(|filter| !filter.trim().is_empty() && filter.trim() != "{}") {
return None;
}
let pool = mongo_pool_for_database(state, &request.connection_id, &request.database).await.ok()?;
- match pool {
- PoolKind::MongoDb(client) => mongo_driver::count_documents(
- &client,
- &request.database,
- &request.collection,
- request.filter.as_deref(),
- false,
- )
- .await
- .ok(),
+ let result = match pool {
+ PoolKind::MongoDb(client) => {
+ mongo_driver::count_documents(
+ &client,
+ &request.database,
+ &request.collection,
+ request.filter.as_deref(),
+ false,
+ )
+ .await
+ }
PoolKind::Agent(client) => {
let mut client = client.lock().await;
client
@@ -2494,10 +2629,15 @@ async fn count_export_documents(state: &AppState, request: &MongoExportRequest)
"accurate": false,
}))
.await
- .ok()
}
- _ => None,
+ _ => return None,
+ };
+ if result.is_err() {
+ if let Some(evidence) = evidence {
+ evidence.unknown();
+ }
}
+ result.ok()
}
async fn for_each_export_json_document<C, F>(
@@ -2505,6 +2645,7 @@ async fn for_each_export_json_document<C, F>(
request: &MongoExportRequest,
is_cancelled: &mut C,
mut on_document: F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<(), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
@@ -2513,7 +2654,7 @@ where
let pool = mongo_pool_for_database(state, &request.connection_id, &request.database).await?;
match pool {
PoolKind::MongoDb(client) => {
- for_each_find_document(
+ let result = for_each_find_document(
&client,
&request.database,
&request.collection,
@@ -2524,9 +2665,17 @@ where
DEFAULT_EXPORT_BATCH_SIZE,
|document| on_document(document_to_canonical_extended_json(&document)),
)
- .await
+ .await;
+ if result.is_err() {
+ if let Some(evidence) = evidence {
+ evidence.unknown();
+ }
+ }
+ result
+ }
+ PoolKind::Agent(client) => {
+ for_each_agent_export_document(&client, request, is_cancelled, on_document, evidence).await
}
- PoolKind::Agent(client) => for_each_agent_export_document(&client, request, is_cancelled, on_document).await,
_ => Err("Not a MongoDB connection".to_string()),
}
}
@@ -2536,6 +2685,7 @@ async fn for_each_agent_export_document<C, F>(
request: &MongoExportRequest,
is_cancelled: &mut C,
mut on_document: F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<(), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
@@ -2545,9 +2695,9 @@ where
// other operation that shares this pooled agent connection.
let supports_cursor = client.lock().await.supports_capability(AgentCapability::MongoFindCursor);
if supports_cursor {
- export_agent_find_cursor(client, request, is_cancelled, &mut on_document).await
+ export_agent_find_cursor(client, request, is_cancelled, &mut on_document, evidence).await
} else {
- export_agent_find_pages(client, request, is_cancelled, &mut on_document).await
+ export_agent_find_pages(client, request, is_cancelled, &mut on_document, evidence).await
}
}
@@ -2662,12 +2812,16 @@ async fn export_agent_find_cursor<C, F>(
request: &MongoExportRequest,
is_cancelled: &mut C,
on_document: &mut F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<(), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
F: FnMut(serde_json::Value) -> Result<(), String>,
{
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
return Err("Export cancelled".to_string());
}
let started: serde_json::Value = {
@@ -2675,21 +2829,37 @@ where
match guard.mongo_start_find_cursor(agent_cursor_find_params(request)).await {
Ok(started) => started,
Err(error) if crate::mongo_ops::is_unknown_agent_method_error(&error, "start_find_cursor") => {
- return export_agent_find_pages(client, request, is_cancelled, on_document).await;
+ return export_agent_find_pages(client, request, is_cancelled, on_document, evidence).await;
+ }
+ Err(error) => {
+ if let Some(evidence) = evidence {
+ evidence.unknown();
+ }
+ return Err(error);
}
- Err(error) => return Err(error),
}
};
let cursor_id = started
.get("cursor_id")
.and_then(serde_json::Value::as_str)
- .ok_or_else(|| "MongoDB Legacy Agent returned an invalid find cursor".to_string())?
+ .ok_or_else(|| {
+ if let Some(evidence) = evidence {
+ evidence.unknown();
+ }
+ "MongoDB Legacy Agent returned an invalid find cursor".to_string()
+ })?
.to_string();
- let result = fetch_agent_find_cursor(client, request, &cursor_id, is_cancelled, on_document).await;
- let _: Result<serde_json::Value, String> = {
+ let mut exhausted = false;
+ let result = fetch_agent_find_cursor(client, request, &cursor_id, is_cancelled, on_document, &mut exhausted).await;
+ let close: Result<serde_json::Value, String> = {
let mut guard = client.lock().await;
guard.mongo_close_find_cursor(serde_json::json!({ "cursor_id": cursor_id })).await
};
+ if !exhausted || close.is_err() {
+ if let Some(evidence) = evidence {
+ evidence.unknown();
+ }
+ }
result
}
@@ -2699,6 +2869,7 @@ async fn fetch_agent_find_cursor<C, F>(
cursor_id: &str,
is_cancelled: &mut C,
on_document: &mut F,
+ confirmed_exhausted: &mut bool,
) -> Result<(), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
@@ -2723,6 +2894,7 @@ where
.map(std::mem::take)
.ok_or_else(|| "MongoDB Legacy Agent returned an invalid find cursor page".to_string())?;
let exhausted = page.get("exhausted").and_then(serde_json::Value::as_bool).unwrap_or(documents.is_empty());
+ *confirmed_exhausted = page.get("exhausted").and_then(serde_json::Value::as_bool) == Some(true);
let empty = documents.is_empty();
for document in documents {
on_document(document)?;
@@ -2738,6 +2910,7 @@ async fn export_agent_find_pages<C, F>(
request: &MongoExportRequest,
is_cancelled: &mut C,
on_document: &mut F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<(), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
@@ -2752,6 +2925,9 @@ where
let mut last_id: Option<serde_json::Value> = None;
loop {
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
return Err("Export cancelled".to_string());
}
let params = match &keyset_base {
@@ -2770,7 +2946,12 @@ where
.to_string(),
);
}
- Err(error) => return Err(error),
+ Err(error) => {
+ if let Some(evidence) = evidence {
+ evidence.unknown();
+ }
+ return Err(error);
+ }
}
};
// The shipped legacy agent answers this method with `documentQueryResult`, so
@@ -2818,6 +2999,7 @@ async fn export_ndjson<C, F>(
started_at: Instant,
is_cancelled: &mut C,
on_progress: &mut F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<(u64, u64), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
@@ -2827,27 +3009,36 @@ where
let mut writer = BufWriter::new(file);
let mut documents_read = 0u64;
let mut bytes_written = 0u64;
- for_each_export_json_document(state, request, is_cancelled, |json| {
- let mut line = json.to_string();
- line.push('\n');
- bytes_written += write_export_line(&mut writer, &line)?;
- documents_read += 1;
- if documents_read == 1 || documents_read.is_multiple_of(500) {
- on_progress(export_progress(
- &request.export_id,
- MongoExportStatus::Running,
- documents_read,
- bytes_written,
- total_documents,
- None,
- started_at,
- ));
- }
- Ok(())
- })
+ for_each_export_json_document(
+ state,
+ request,
+ is_cancelled,
+ |json| {
+ let mut line = json.to_string();
+ line.push('\n');
+ bytes_written += write_export_line(&mut writer, &line)?;
+ documents_read += 1;
+ if documents_read == 1 || documents_read.is_multiple_of(500) {
+ on_progress(export_progress(
+ &request.export_id,
+ MongoExportStatus::Running,
+ documents_read,
+ bytes_written,
+ total_documents,
+ None,
+ started_at,
+ ));
+ }
+ Ok(())
+ },
+ evidence,
+ )
.await?;
writer.flush().map_err(|error| error.to_string())?;
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
return Err("Export cancelled".to_string());
}
Ok((documents_read, bytes_written))
@@ -2894,12 +3085,16 @@ async fn export_bson<C, F>(
started_at: Instant,
is_cancelled: &mut C,
on_progress: &mut F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<(u64, u64), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
F: FnMut(MongoExportProgress),
{
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
return Err("Export cancelled".to_string());
}
let pool = mongo_pool_for_database(state, &request.connection_id, &request.database).await?;
@@ -2948,9 +3143,13 @@ where
let mut poll_cancel = tokio::time::interval(std::time::Duration::from_millis(100));
loop {
tokio::select! {
- result = &mut export => { result?; break; }
+ result = &mut export => {
+ if result.is_err() { if let Some(evidence) = evidence { evidence.unknown(); } }
+ result?; break;
+ }
_ = poll_cancel.tick() => {
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence { evidence.unknown(); }
return Err("Export cancelled".to_string());
}
}
@@ -2964,15 +3163,22 @@ where
if !client.lock().await.supports_capability(AgentCapability::MongoFindCursor) {
return Err("BSON export over the MongoDB Legacy Agent needs find-cursor support; upgrade or reinstall the MongoDB Legacy driver".into());
}
- for_each_agent_export_document(client, request, is_cancelled, |value| {
- write_document(mongo_driver::json_object_to_document_extended_json(&value)?)
- })
+ for_each_agent_export_document(
+ client,
+ request,
+ is_cancelled,
+ |value| write_document(mongo_driver::json_object_to_document_extended_json(&value)?),
+ evidence,
+ )
.await?;
}
_ => return Err("Not a MongoDB connection".to_string()),
}
writer.finish()?;
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
return Err("Export cancelled".to_string());
}
Ok((documents_read, bytes_written))
@@ -2988,12 +3194,16 @@ async fn export_csv<C, F>(
started_at: Instant,
is_cancelled: &mut C,
on_progress: &mut F,
+ evidence: Option<&MongoExportEvidence>,
) -> Result<(u64, u64), String>
where
C: FnMut(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send>>,
F: FnMut(MongoExportProgress),
{
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
return Err("Export cancelled".to_string());
}
let file = File::create(temp).map_err(|error| error.to_string())?;
@@ -3005,20 +3215,40 @@ where
let mut documents_read = 0u64;
let mut bytes_written = 0u64;
- for_each_export_json_document(state, request, is_cancelled, |json| {
- if !header_ready {
- collect_csv_fields(&json, &mut fields, &mut seen)?;
- buffered.push(json);
- if buffered.len() >= CSV_FIELD_DISCOVERY_DOCS {
- write_csv_header_and_buffer(
- request.include_header,
- &mut fields,
- &mut buffered,
- &mut writer,
- &mut bytes_written,
- &mut documents_read,
- )?;
- header_ready = true;
+ for_each_export_json_document(
+ state,
+ request,
+ is_cancelled,
+ |json| {
+ if !header_ready {
+ collect_csv_fields(&json, &mut fields, &mut seen)?;
+ buffered.push(json);
+ if buffered.len() >= CSV_FIELD_DISCOVERY_DOCS {
+ write_csv_header_and_buffer(
+ request.include_header,
+ &mut fields,
+ &mut buffered,
+ &mut writer,
+ &mut bytes_written,
+ &mut documents_read,
+ )?;
+ header_ready = true;
+ on_progress(export_progress(
+ &request.export_id,
+ MongoExportStatus::Running,
+ documents_read,
+ bytes_written,
+ total_documents,
+ None,
+ started_at,
+ ));
+ }
+ return Ok(());
+ }
+ let line = format_csv_document_line(&fields, &json);
+ bytes_written += write_export_line(&mut writer, &line)?;
+ documents_read += 1;
+ if documents_read.is_multiple_of(500) {
on_progress(export_progress(
&request.export_id,
MongoExportStatus::Running,
@@ -3029,24 +3259,10 @@ where
started_at,
));
}
- return Ok(());
- }
- let line = format_csv_document_line(&fields, &json);
- bytes_written += write_export_line(&mut writer, &line)?;
- documents_read += 1;
- if documents_read.is_multiple_of(500) {
- on_progress(export_progress(
- &request.export_id,
- MongoExportStatus::Running,
- documents_read,
- bytes_written,
- total_documents,
- None,
- started_at,
- ));
- }
- Ok(())
- })
+ Ok(())
+ },
+ evidence,
+ )
.await?;
if !header_ready {
write_csv_header_and_buffer(
@@ -3060,6 +3276,9 @@ where
}
writer.flush().map_err(|error| error.to_string())?;
if is_cancelled(&request.export_id).await {
+ if let Some(evidence) = evidence {
+ evidence.cancelled();
+ }
return Err("Export cancelled".to_string());
}
Ok((documents_read, bytes_written))
@@ -3083,6 +3302,124 @@ pub fn format_mongo_csv_row(fields: &[String], document: &serde_json::Value) ->
#[cfg(test)]
mod tests {
+ #[tokio::test]
+ async fn reported_mongo_cursor_requires_explicit_exhaustion_and_actual_close() {
+ use super::*;
+ use crate::db::agent_driver::{AgentDriverClient, AgentLaunchSpec, AgentRuntimeClient, PooledAgentClient};
+ use std::sync::Arc;
+ for mode in ["exhausted", "missing", "early", "close_error", "count_error"] {
+ let dir = std::env::temp_dir().join(format!("dbx-mongo-completion-{}", uuid::Uuid::new_v4()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let script = dir.join("agent.py");
+ std::fs::write(&script, r#"import json,sys,time
+mode=sys.argv[1]
+print(json.dumps({'ready':True}),flush=True)
+for line in sys.stdin:
+ req=json.loads(line); method=req['method']; result={}
+ if method=='handshake': result={'protocolVersion':2,'agentProtocolVersion':2,'capabilities':['multi_session','mongo_find_cursor']}
+ elif method.endswith('count_documents'):
+ print(json.dumps({'jsonrpc':'2.0','id':req['id'],'error':{'code':-1,'message':'count reply failed'}}),flush=True); continue
+ elif method.endswith('start_find_cursor'): result={'cursor_id':'cursor'}
+ elif method.endswith('fetch_find_cursor'):
+ result={'documents':[] if mode=='missing' else [{'x':1}]}
+ if mode!='missing': result['exhausted']=mode!='early'
+ elif method.endswith('close_find_cursor'):
+ time.sleep(0.05)
+ if mode=='close_error':
+ print(json.dumps({'jsonrpc':'2.0','id':req['id'],'error':{'code':-1,'message':'close failed'}}),flush=True); continue
+ result={'ok':True}
+ print(json.dumps({'jsonrpc':'2.0','id':req['id'],'result':result}),flush=True)
+"#).unwrap();
+ let runtime = AgentRuntimeClient::spawn(
+ AgentLaunchSpec::new(if cfg!(windows) { "python" } else { "python3" })
+ .with_args([script.to_string_lossy().into_owned(), mode.to_string()]),
+ "test",
+ )
+ .await
+ .unwrap();
+ runtime.increment_session_count();
+ let client =
+ Arc::new(PooledAgentClient::new(AgentDriverClient::shared_session(runtime, "mongo-export".into())));
+ let request: MongoExportRequest = serde_json::from_value(serde_json::json!({"exportId":"completion", "connectionId":"conn", "database":"db", "collection":"docs", "format":"ndjson", "filePath":dir.join("out.json").to_string_lossy()})).unwrap();
+ let evidence = MongoExportEvidence::default();
+ if mode == "count_error" {
+ let storage = crate::persistence::test_storage::open(&dir.join("storage.db")).await.unwrap();
+ let state = AppState::new(storage);
+ let config = serde_json::from_value(serde_json::json!({
+ "id":"conn", "name":"Mongo", "db_type":"mongodb", "host":"localhost",
+ "port":27017, "username":"", "password":"", "database":"db"
+ }))
+ .unwrap();
+ state.configs.write().await.insert("conn".into(), config);
+ state
+ .update_connection_pools(|pools| {
+ pools.insert("conn:db".into(), PoolKind::Agent(client.clone()));
+ })
+ .await;
+ let mut progress = Vec::new();
+ let outcome = export_mongodb_query_reported(
+ &state,
+ &request,
+ |_| Box::pin(std::future::ready(false)),
+ |value| progress.push(value),
+ )
+ .await;
+ assert!(matches!(outcome, MongoExportOutcome::Unknown { .. }));
+ assert_eq!(progress.len(), 1, "count failure must not start the writer");
+ assert!(!std::path::Path::new(&request.file_path).exists());
+ assert!(!std::fs::read_dir(&dir).unwrap().any(|entry| entry
+ .unwrap()
+ .file_name()
+ .to_string_lossy()
+ .ends_with("dbx-export.tmp")));
+ let old =
+ export_mongodb_query_core(&state, &request, |_| Box::pin(std::future::ready(false)), |_| {}).await;
+ assert!(old.is_ok(), "default count tolerance must remain: {old:?}");
+ assert!(std::path::Path::new(&request.file_path).exists());
+ state.shutdown(std::time::Duration::from_secs(1)).await;
+ drop(client);
+ let _ = std::fs::remove_dir_all(dir);
+ continue;
+ }
+ let started = Instant::now();
+ let mut checks = 0;
+ let result = export_agent_find_cursor(
+ &client,
+ &request,
+ &mut |_| {
+ checks += 1;
+ Box::pin(std::future::ready(mode == "early" && checks > 2))
+ },
+ &mut |_| Ok(()),
+ Some(&evidence),
+ )
+ .await;
+ assert!(started.elapsed() >= std::time::Duration::from_millis(40));
+ assert_eq!(evidence.unknown.load(std::sync::atomic::Ordering::Relaxed), mode != "exhausted", "{mode}");
+ if mode == "exhausted" {
+ assert!(result.is_ok());
+ }
+ drop(client);
+ let _ = std::fs::remove_dir_all(dir);
+ }
+ }
+
+ #[test]
+ fn reported_mongo_temp_cleanup_checks_actual_deletion() {
+ use super::*;
+ let dir = std::env::temp_dir().join(format!("dbx-mongo-cleanup-{}", uuid::Uuid::new_v4()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let evidence = MongoExportEvidence::default();
+ let path = dir.join("temp");
+ std::fs::write(&path, "task data").unwrap();
+ cleanup_export_temp(&path, Some(&evidence)).unwrap();
+ assert!(!path.exists());
+ cleanup_export_temp(&path, Some(&evidence)).unwrap();
+ std::fs::create_dir(&path).unwrap();
+ assert!(cleanup_export_temp(&path, Some(&evidence)).is_err());
+ assert!(evidence.unknown.load(std::sync::atomic::Ordering::Relaxed));
+ std::fs::remove_dir_all(dir).unwrap();
+ }
use super::*;
use mongodb::bson::{doc, Bson, Document};
use std::io::Cursor;
diff --git a/crates/dbx-core/src/data/query_result_export.rs b/crates/dbx-core/src/data/query_result_export.rs
index eaf332dcc6..de16c6ef56 100644
--- a/crates/dbx-core/src/data/query_result_export.rs
+++ b/crates/dbx-core/src/data/query_result_export.rs
@@ -191,6 +191,14 @@ impl StagedExportTarget {
}
pub fn commit(self) -> Result<(), String> {
+ self.commit_inner(false).result
+ }
+
+ pub fn commit_with_completion(self) -> crate::table_export::ExportCompletion {
+ self.commit_inner(true)
+ }
+
+ fn prepare_commit(&self) -> Result<(), String> {
let staged_file = std::fs::OpenOptions::new()
.read(true)
.write(true)
@@ -203,10 +211,40 @@ impl StagedExportTarget {
}
staged_file.sync_all().map_err(|error| format!("Failed to synchronize export file: {error}"))?;
drop(staged_file);
- self.temporary
- .persist(&self.destination)
- .map(|_| ())
- .map_err(|error| format!("Failed to replace export destination: {}", error.error))
+ Ok(())
+ }
+
+ fn commit_inner(self, report_completion: bool) -> crate::table_export::ExportCompletion {
+ if let Err(error) = self.prepare_commit() {
+ let cleanup = if report_completion {
+ self.discard()
+ } else {
+ drop(self);
+ Ok(())
+ };
+ return crate::table_export::ExportCompletion { result: Err(error), cleanup };
+ }
+ match self.temporary.persist(&self.destination) {
+ Ok(()) => crate::table_export::ExportCompletion { result: Ok(()), cleanup: Ok(()) },
+ Err(error) => {
+ let message = format!("Failed to replace export destination: {}", error.error);
+ let cleanup = if report_completion {
+ Self { destination: self.destination, temporary: error.path }.discard()
+ } else {
+ drop(error.path);
+ Ok(())
+ };
+ crate::table_export::ExportCompletion { result: Err(message), cleanup }
+ }
+ }
+ }
+
+ pub fn discard(self) -> Result<(), String> {
+ match self.temporary.close() {
+ Ok(()) => Ok(()),
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
+ Err(error) => Err(format!("Failed to remove staged export file: {error}")),
+ }
}
}
@@ -451,13 +489,18 @@ struct JsonStreamWriter {
}
impl JsonStreamWriter {
+ #[cfg(test)]
fn create(request: &QueryResultExportRequest) -> Result<Self, String> {
- let target = StagedExportTarget::new(&request.file_path)?;
- let mut file = BufWriter::new(
- File::create(target.path()).map_err(|e| format!("Failed to create JSON export temp file: {e}"))?,
- );
+ Self::create_for_export(request, false)
+ }
+
+ fn create_for_export(request: &QueryResultExportRequest, externally_staged: bool) -> Result<Self, String> {
+ let target = if externally_staged { None } else { Some(StagedExportTarget::new(&request.file_path)?) };
+ let path = target.as_ref().map_or_else(|| Path::new(&request.file_path), StagedExportTarget::path);
+ let mut file =
+ BufWriter::new(File::create(path).map_err(|e| format!("Failed to create JSON export temp file: {e}"))?);
file.write_all(b"[\n").map_err(|e| format!("Failed to start JSON export: {e}"))?;
- Ok(Self { file: Some(file), target: Some(target), wrote_row: false })
+ Ok(Self { file: Some(file), target, wrote_row: false })
}
fn write_row(&mut self, columns: &[String], row: &[Value]) -> Result<(), String> {
@@ -489,22 +532,26 @@ impl JsonStreamWriter {
file.write_all(b"\n]\n").map_err(|e| format!("Failed to finish JSON export: {e}"))?;
file.flush().map_err(|e| format!("Failed to flush JSON export: {e}"))?;
self.file.take();
- self.target
- .take()
- .ok_or_else(|| "JSON export target already finalized".to_string())?
- .commit()
- .map_err(|error| format!("Failed to finalize JSON export file: {error}"))
+ if let Some(target) = self.target.take() {
+ target.commit().map_err(|error| format!("Failed to finalize JSON export file: {error}"))?;
+ }
+ Ok(())
}
}
impl SqlInsertWriter {
/// Create the writer and open the temp file. Column metadata is supplied later
/// via [`SqlInsertWriter::set_columns`] once the executed result is known.
+ #[cfg(test)]
fn create(request: &QueryResultExportRequest) -> Result<Self, String> {
- let target = StagedExportTarget::new(&request.file_path)?;
- let file = BufWriter::new(
- File::create(target.path()).map_err(|e| format!("Failed to create SQL export temp file: {e}"))?,
- );
+ Self::create_for_export(request, false)
+ }
+
+ fn create_for_export(request: &QueryResultExportRequest, externally_staged: bool) -> Result<Self, String> {
+ let target = if externally_staged { None } else { Some(StagedExportTarget::new(&request.file_path)?) };
+ let path = target.as_ref().map_or_else(|| Path::new(&request.file_path), StagedExportTarget::path);
+ let file =
+ BufWriter::new(File::create(path).map_err(|e| format!("Failed to create SQL export temp file: {e}"))?);
let table_name = request
.export_table_name
.as_deref()
@@ -513,7 +560,7 @@ impl SqlInsertWriter {
.to_string();
Ok(Self {
file: Some(file),
- target: Some(target),
+ target,
pending_rows: Vec::new(),
pending_spatial_values: Vec::new(),
insert_mode: request.insert_mode,
@@ -630,11 +677,10 @@ impl SqlInsertWriter {
file.flush().map_err(|e| format!("Failed to flush SQL file: {e}"))?;
}
self.file.take();
- self.target
- .take()
- .ok_or_else(|| "SQL export target already finalized".to_string())?
- .commit()
- .map_err(|error| format!("Failed to finalize SQL export file: {error}"))
+ if let Some(target) = self.target.take() {
+ target.commit().map_err(|error| format!("Failed to finalize SQL export file: {error}"))?;
+ }
+ Ok(())
}
}
@@ -963,6 +1009,26 @@ pub async fn export_query_result_core(
cancel_token: Option<CancellationToken>,
on_progress: impl Fn(TableExportProgress),
) -> Result<(), String> {
+ export_query_result_with_cleanup(state, request, cancel_token, on_progress, false).await.result
+}
+
+/// The caller owns the staged destination and confirms its commit or removal.
+pub async fn export_query_result_core_with_completion(
+ state: &AppState,
+ request: &QueryResultExportRequest,
+ cancel_token: Option<CancellationToken>,
+ on_progress: impl Fn(TableExportProgress),
+) -> crate::table_export::ExportCompletion {
+ export_query_result_with_cleanup(state, request, cancel_token, on_progress, true).await
+}
+
+async fn export_query_result_with_cleanup(
+ state: &AppState,
+ request: &QueryResultExportRequest,
+ cancel_token: Option<CancellationToken>,
+ on_progress: impl Fn(TableExportProgress),
+ report_completion: bool,
+) -> crate::table_export::ExportCompletion {
let mut session_id: Option<String> = None;
let mut duckdb_snapshot = None;
let result = export_query_result_core_inner(
@@ -971,16 +1037,23 @@ pub async fn export_query_result_core(
cancel_token,
&on_progress,
&mut session_id,
+ report_completion,
&mut duckdb_snapshot,
)
.await;
- if let Some(snapshot) = duckdb_snapshot {
- snapshot.close(state).await;
- }
-
+ let mut cleanup = if let Some(snapshot) = duckdb_snapshot {
+ if report_completion {
+ snapshot.close_with_completion(state).await
+ } else {
+ snapshot.close(state).await;
+ Ok(())
+ }
+ } else {
+ Ok(())
+ };
if let Some(session_id) = session_id {
- let _ = close_query_session(
+ let cursor_close = close_query_session(
state,
&request.connection_id,
&request.database,
@@ -989,14 +1062,25 @@ pub async fn export_query_result_core(
None,
)
.await;
+ if report_completion {
+ cleanup = cleanup.and(cursor_close.map(|_| ()));
+ }
}
if let Some(client_session_id) = request.client_session_id.as_deref() {
let database = request.database.trim();
let database = if database.is_empty() { None } else { Some(database) };
- let _ = state.close_client_session_pool(&request.connection_id, database, client_session_id).await;
+ if report_completion {
+ let pool_close = state
+ .close_client_session_pool_with_completion(&request.connection_id, database, client_session_id)
+ .await
+ .map(|_| ());
+ cleanup = cleanup.and(pool_close);
+ } else {
+ let _ = state.close_client_session_pool(&request.connection_id, database, client_session_id).await;
+ }
}
- result
+ crate::table_export::ExportCompletion { result, cleanup }
}
async fn export_query_result_core_inner(
@@ -1005,6 +1089,7 @@ async fn export_query_result_core_inner(
cancel_token: Option<CancellationToken>,
on_progress: &impl Fn(TableExportProgress),
session_id: &mut Option<String>,
+ externally_staged: bool,
duckdb_snapshot: &mut Option<DuckDbExportSnapshot>,
) -> Result<(), String> {
let format = request.format.to_lowercase();
@@ -1026,23 +1111,58 @@ async fn export_query_result_core_inner(
let use_agent_cursor = request.use_agent_cursor && txn_session_id.is_none();
if txn_session_id.is_none() {
- if try_export_postgres_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await? {
+ if try_export_postgres_query_result_stream(
+ state,
+ request,
+ &format,
+ cancel_token.clone(),
+ on_progress,
+ externally_staged,
+ )
+ .await?
+ {
return Ok(());
}
- if try_export_sqlserver_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await? {
+ if try_export_sqlserver_query_result_stream(
+ state,
+ request,
+ &format,
+ cancel_token.clone(),
+ on_progress,
+ externally_staged,
+ )
+ .await?
+ {
return Ok(());
}
// MySQL does not guarantee a stable row order for independent LIMIT/OFFSET
// executions without ORDER BY, so query-result export must stream one run.
- if try_export_mysql_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await? {
+ if try_export_mysql_query_result_stream(
+ state,
+ request,
+ &format,
+ cancel_token.clone(),
+ on_progress,
+ externally_staged,
+ )
+ .await?
+ {
return Ok(());
}
// ClickHouse HTTP pagination is unsafe for unsorted result sets; stream one
// response so large exports preserve the server's single execution order.
- if try_export_clickhouse_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await?
+ if try_export_clickhouse_query_result_stream(
+ state,
+ request,
+ &format,
+ cancel_token.clone(),
+ on_progress,
+ externally_staged,
+ )
+ .await?
{
return Ok(());
}
@@ -1095,9 +1215,10 @@ async fn export_query_result_core_inner(
return Err(error.to_string());
}
- let mut json_writer = if format == "json" { Some(JsonStreamWriter::create(request)?) } else { None };
+ let mut json_writer =
+ if format == "json" { Some(JsonStreamWriter::create_for_export(request, externally_staged)?) } else { None };
let mut sql_writer: Option<SqlInsertWriter> =
- if format == "sql" { Some(SqlInsertWriter::create(request)?) } else { None };
+ if format == "sql" { Some(SqlInsertWriter::create_for_export(request, externally_staged)?) } else { None };
loop {
if cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
@@ -1422,6 +1543,7 @@ async fn try_export_postgres_query_result_stream(
format: &str,
cancel_token: Option<CancellationToken>,
on_progress: &impl Fn(TableExportProgress),
+ externally_staged: bool,
) -> Result<bool, String> {
if request.use_agent_cursor
|| !crate::sql::starts_with_executable_sql_keyword(
@@ -1476,9 +1598,10 @@ async fn try_export_postgres_query_result_stream(
};
let mut xlsx = None;
let mut text_buffer = String::new();
- let mut json_writer = if format == "json" { Some(JsonStreamWriter::create(request)?) } else { None };
+ let mut json_writer =
+ if format == "json" { Some(JsonStreamWriter::create_for_export(request, externally_staged)?) } else { None };
let mut sql_writer: Option<SqlInsertWriter> =
- if format == "sql" { Some(SqlInsertWriter::create(request)?) } else { None };
+ if format == "sql" { Some(SqlInsertWriter::create_for_export(request, externally_staged)?) } else { None };
let budget = operation_budget_for_pool_key(state, &pool_key, query_export_timeout(request.timeout_secs)).await;
let cancel_context = state.get_postgres_cancel_context(&pool_key).await;
@@ -1620,6 +1743,7 @@ async fn try_export_mysql_query_result_stream(
format: &str,
cancel_token: Option<CancellationToken>,
on_progress: &impl Fn(TableExportProgress),
+ externally_staged: bool,
) -> Result<bool, String> {
if request.use_agent_cursor {
return Ok(false);
@@ -1679,9 +1803,10 @@ async fn try_export_mysql_query_result_stream(
};
let mut xlsx = None;
let mut text_buffer = String::new();
- let mut json_writer = if format == "json" { Some(JsonStreamWriter::create(request)?) } else { None };
+ let mut json_writer =
+ if format == "json" { Some(JsonStreamWriter::create_for_export(request, externally_staged)?) } else { None };
let mut sql_writer: Option<SqlInsertWriter> =
- if format == "sql" { Some(SqlInsertWriter::create(request)?) } else { None };
+ if format == "sql" { Some(SqlInsertWriter::create_for_export(request, externally_staged)?) } else { None };
let query_timeout = query_export_timeout(request.timeout_secs);
let operation_budget = operation_budget_for_pool_key(state, &pool_key, query_timeout).await;
let mut conn = crate::db::mysql::get_conn_with_health_check_with_cancel(
@@ -1914,6 +2039,7 @@ async fn try_export_clickhouse_query_result_stream(
format: &str,
cancel_token: Option<CancellationToken>,
on_progress: &impl Fn(TableExportProgress),
+ externally_staged: bool,
) -> Result<bool, String> {
if request.database_type != DatabaseType::ClickHouse
|| request.use_agent_cursor
@@ -1969,9 +2095,10 @@ async fn try_export_clickhouse_query_result_stream(
};
let mut xlsx = None;
let mut text_buffer = String::new();
- let mut json_writer = if format == "json" { Some(JsonStreamWriter::create(request)?) } else { None };
+ let mut json_writer =
+ if format == "json" { Some(JsonStreamWriter::create_for_export(request, externally_staged)?) } else { None };
let mut sql_writer: Option<SqlInsertWriter> =
- if format == "sql" { Some(SqlInsertWriter::create(request)?) } else { None };
+ if format == "sql" { Some(SqlInsertWriter::create_for_export(request, externally_staged)?) } else { None };
let query_timeout = query_export_timeout(request.timeout_secs);
let clickhouse_database = if database.is_empty() { "default" } else { database };
@@ -2119,6 +2246,7 @@ async fn try_export_sqlserver_query_result_stream(
format: &str,
cancel_token: Option<CancellationToken>,
on_progress: &impl Fn(TableExportProgress),
+ externally_staged: bool,
) -> Result<bool, String> {
if request.database_type != DatabaseType::SqlServer || request.use_agent_cursor {
return Ok(false);
@@ -2155,9 +2283,10 @@ async fn try_export_sqlserver_query_result_stream(
};
let mut xlsx = None;
let mut text_buffer = String::new();
- let mut json_writer = if format == "json" { Some(JsonStreamWriter::create(request)?) } else { None };
+ let mut json_writer =
+ if format == "json" { Some(JsonStreamWriter::create_for_export(request, externally_staged)?) } else { None };
let mut sql_writer: Option<SqlInsertWriter> =
- if format == "sql" { Some(SqlInsertWriter::create(request)?) } else { None };
+ if format == "sql" { Some(SqlInsertWriter::create_for_export(request, externally_staged)?) } else { None };
let query_timeout = query_export_timeout(request.timeout_secs);
let mut client = match cancel_token.as_ref() {
@@ -2411,6 +2540,32 @@ mod tests {
assert_eq!(std::fs::read_to_string(destination).expect("read destination"), "original");
}
+ #[test]
+ fn staged_export_completion_distinguishes_commit_failure_from_cleanup_failure() {
+ let dir = tempfile::tempdir().expect("temp dir");
+ let destination = dir.path().join("result.csv");
+ std::fs::write(&destination, "original").expect("original destination");
+ let target = StagedExportTarget::new(destination.to_str().unwrap()).unwrap();
+ let staged = target.path().to_path_buf();
+ std::fs::remove_file(&staged).unwrap();
+ std::fs::create_dir(&staged).unwrap();
+ let completion = target.commit_with_completion();
+ assert!(completion.result.is_err());
+ assert!(completion.cleanup.is_err());
+ assert_eq!(std::fs::read_to_string(&destination).unwrap(), "original");
+ std::fs::remove_dir(staged).unwrap();
+
+ let blocked_destination = dir.path().join("destination-directory");
+ std::fs::create_dir(&blocked_destination).unwrap();
+ let target = StagedExportTarget::new(blocked_destination.to_str().unwrap()).unwrap();
+ let staged = target.path().to_path_buf();
+ let completion = target.commit_with_completion();
+ assert!(completion.result.is_err());
+ assert!(completion.cleanup.is_ok());
+ assert!(!staged.exists());
+ assert!(blocked_destination.is_dir());
+ }
+
#[test]
fn staged_export_targets_are_unique_same_directory_and_replace_existing_destination() {
let dir = tempfile::tempdir().expect("temp dir");
@@ -2987,6 +3142,48 @@ mod tests {
);
}
+ #[test]
+ fn externally_staged_writers_leave_cleanup_with_the_caller_on_cancel_and_flush_failure() {
+ for format in ["json", "sql"] {
+ for flush_failure in [false, true] {
+ let dir = tempfile::tempdir().unwrap();
+ let destination = dir.path().join("result");
+ std::fs::write(&destination, "original").unwrap();
+ let target = StagedExportTarget::new(destination.to_str().unwrap()).unwrap();
+ let mut req = request(format, None, None);
+ req.file_path = target.path_string().unwrap();
+ if format == "json" {
+ let mut writer = JsonStreamWriter::create_for_export(&req, true).unwrap();
+ assert!(writer.target.is_none());
+ if flush_failure {
+ writer.file.take();
+ writer.file = Some(BufWriter::new(File::open(target.path()).unwrap()));
+ writer.write_row(&["ID".into()], &[json!(7)]).unwrap();
+ assert!(writer.finish().unwrap_err().contains("flush"));
+ } else {
+ drop(writer);
+ }
+ } else {
+ let mut writer = SqlInsertWriter::create_for_export(&req, true).unwrap();
+ assert!(writer.target.is_none());
+ if flush_failure {
+ writer.set_columns(vec!["ID".into()], &["NUMBER".into()], &[], &req).unwrap();
+ writer.file.take();
+ writer.file = Some(BufWriter::new(File::open(target.path()).unwrap()));
+ writer.write_row(vec![json!(7)], None).unwrap();
+ assert!(writer.finish().unwrap_err().contains("flush"));
+ } else {
+ drop(writer);
+ }
+ }
+ assert_eq!(std::fs::read_dir(dir.path()).unwrap().count(), 2);
+ target.discard().unwrap();
+ assert_eq!(std::fs::read_dir(dir.path()).unwrap().count(), 1);
+ assert_eq!(std::fs::read_to_string(destination).unwrap(), "original");
+ }
+ }
+ }
+
#[test]
fn json_stream_writer_emits_a_valid_array_without_retaining_rows() {
let dir = tempfile::tempdir().expect("temp dir");
diff --git a/crates/dbx-core/src/data/table_export.rs b/crates/dbx-core/src/data/table_export.rs
index ce4d764536..cf9654d8ba 100644
--- a/crates/dbx-core/src/data/table_export.rs
+++ b/crates/dbx-core/src/data/table_export.rs
@@ -728,6 +728,7 @@ async fn fetch_table_export_batch(
table_read_completed: &mut bool,
duckdb_snapshot: Option<&DuckDbExportSnapshot>,
cancel_token: CancellationToken,
+ cleanup_error: &std::sync::Mutex<Option<String>>,
) -> Result<QueryResult, String> {
if let Some(snapshot) = duckdb_snapshot {
return snapshot.page(state, offset, active_batch_size, Some(cancel_token)).await;
@@ -917,7 +918,8 @@ async fn fetch_table_export_batch(
if cancel_token.is_cancelled() {
cursor_session.take();
} else {
- close_table_export_cursor_if_open(state, pool_key, request, cursor_session).await;
+ close_table_export_cursor_if_open(state, pool_key, request, cursor_session, cleanup_error)
+ .await;
}
Err(error)
}
@@ -975,23 +977,28 @@ async fn close_table_export_cursor_if_open(
pool_key: &str,
request: &TableExportRequest,
cursor_session: &mut Option<TableExportCursorSession>,
+ cleanup_error: &std::sync::Mutex<Option<String>>,
) {
let Some(session) = cursor_session.take() else {
return;
};
- match session {
+ let result = match session {
TableExportCursorSession::Agent(session_id) => {
let pool_handle = state.pool_handle(pool_key).await;
let Some(PoolKind::Agent(client)) = pool_handle.as_ref() else {
+ cleanup_error
+ .lock()
+ .unwrap_or_else(|poisoned| poisoned.into_inner())
+ .get_or_insert_with(|| "Export cursor close completion was not confirmed".to_string());
return;
};
let client = client.clone();
let mut client = client.lock().await;
- let _ = client.close_table_read_session::<bool>(&session_id).await;
+ client.close_table_read_session::<bool>(&session_id).await.map(|_| ())
}
TableExportCursorSession::ExternalDriver(session_id) => {
let client_session_id = table_export_client_session_id(&request.export_id);
- let _ = close_query_session(
+ close_query_session(
state,
&request.connection_id,
&request.database,
@@ -999,8 +1006,12 @@ async fn close_table_export_cursor_if_open(
Some(&client_session_id),
None,
)
- .await;
+ .await
+ .map(|_| ())
}
+ };
+ if let Err(error) = result {
+ cleanup_error.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).get_or_insert(error);
}
}
@@ -1575,6 +1586,28 @@ pub async fn export_table_data_core(
request: &TableExportRequest,
on_progress: impl Fn(TableExportProgress),
) -> Result<(), String> {
+ export_table_data_with_cleanup(state, request, on_progress, false).await.result
+}
+
+pub struct ExportCompletion {
+ pub result: Result<(), String>,
+ pub cleanup: Result<(), String>,
+}
+
+pub async fn export_table_data_core_with_completion(
+ state: &AppState,
+ request: &TableExportRequest,
+ on_progress: impl Fn(TableExportProgress),
+) -> ExportCompletion {
+ export_table_data_with_cleanup(state, request, on_progress, true).await
+}
+
+async fn export_table_data_with_cleanup(
+ state: &AppState,
+ request: &TableExportRequest,
+ on_progress: impl Fn(TableExportProgress),
+ report_completion: bool,
+) -> ExportCompletion {
let cancelled = Arc::new(AtomicBool::new(false));
let cancel_token = CancellationToken::new();
let cancel_watcher =
@@ -1584,6 +1617,7 @@ pub async fn export_table_data_core(
last_rows_exported.store(progress.rows_exported, Ordering::SeqCst);
on_progress(progress);
};
+ let cleanup_error = std::sync::Mutex::new(None);
let mut duckdb_snapshot = None;
let result = export_table_data_core_inner(
state,
@@ -1591,16 +1625,43 @@ pub async fn export_table_data_core(
&tracked_progress,
cancelled.clone(),
cancel_token.clone(),
+ &cleanup_error,
&mut duckdb_snapshot,
)
.await;
cancel_watcher.abort();
- if let Some(snapshot) = duckdb_snapshot {
- snapshot.close(state).await;
- }
+ let snapshot_cleanup = if let Some(snapshot) = duckdb_snapshot {
+ if report_completion {
+ snapshot.close_with_completion(state).await
+ } else {
+ snapshot.close(state).await;
+ Ok(())
+ }
+ } else {
+ Ok(())
+ };
let client_session_id = table_export_client_session_id(&request.export_id);
- let _ = state.close_client_session_pool(&request.connection_id, Some(&request.database), &client_session_id).await;
- match result {
+ let pool_cleanup = if report_completion {
+ state
+ .close_client_session_pool_with_completion(
+ &request.connection_id,
+ Some(&request.database),
+ &client_session_id,
+ )
+ .await
+ .map(|_| ())
+ } else {
+ let _ =
+ state.close_client_session_pool(&request.connection_id, Some(&request.database), &client_session_id).await;
+ Ok(())
+ };
+ let mut cleanup = snapshot_cleanup.and(pool_cleanup);
+ if report_completion {
+ if let Some(error) = cleanup_error.into_inner().unwrap_or_else(|poisoned| poisoned.into_inner()) {
+ cleanup = Err(error);
+ }
+ }
+ let result = match result {
Err(error) if cancelled.load(Ordering::SeqCst) || error == crate::query::canceled_error() => {
on_progress(TableExportProgress {
export_id: request.export_id.clone(),
@@ -1613,7 +1674,8 @@ pub async fn export_table_data_core(
Ok(())
}
result => result,
- }
+ };
+ ExportCompletion { result, cleanup }
}
async fn export_table_data_core_inner(
@@ -1622,6 +1684,7 @@ async fn export_table_data_core_inner(
on_progress: &impl Fn(TableExportProgress),
cancelled: Arc<AtomicBool>,
cancel_token: CancellationToken,
+ cleanup_error: &std::sync::Mutex<Option<String>>,
duckdb_snapshot: &mut Option<DuckDbExportSnapshot>,
) -> Result<(), String> {
// 1. Get database type
@@ -1871,7 +1934,8 @@ async fn export_table_data_core_inner(
status: ExportStatus::Cancelled,
error_message: Some("Export cancelled".to_string()),
});
- close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session).await;
+ close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session, cleanup_error)
+ .await;
return Ok(());
}
@@ -1897,6 +1961,7 @@ async fn export_table_data_core_inner(
&mut table_read_completed,
duckdb_snapshot.as_ref(),
cancel_token.clone(),
+ cleanup_error,
)
.await?;
let row_count = result.rows.len();
@@ -1972,7 +2037,8 @@ async fn export_table_data_core_inner(
status: ExportStatus::Cancelled,
error_message: Some("Export cancelled".to_string()),
});
- close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session).await;
+ close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session, cleanup_error)
+ .await;
return Ok(());
}
@@ -1998,6 +2064,7 @@ async fn export_table_data_core_inner(
&mut table_read_completed,
duckdb_snapshot.as_ref(),
cancel_token.clone(),
+ cleanup_error,
)
.await?;
let row_count = result.rows.len();
@@ -2087,7 +2154,8 @@ async fn export_table_data_core_inner(
status: ExportStatus::Cancelled,
error_message: Some("Export cancelled".to_string()),
});
- close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session).await;
+ close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session, cleanup_error)
+ .await;
return Ok(());
}
@@ -2113,6 +2181,7 @@ async fn export_table_data_core_inner(
&mut table_read_completed,
duckdb_snapshot.as_ref(),
cancel_token.clone(),
+ cleanup_error,
)
.await?;
let row_count = result.rows.len();
@@ -2184,7 +2253,8 @@ async fn export_table_data_core_inner(
status: ExportStatus::Cancelled,
error_message: Some("Export cancelled".to_string()),
});
- close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session).await;
+ close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session, cleanup_error)
+ .await;
return Ok(());
}
@@ -2210,6 +2280,7 @@ async fn export_table_data_core_inner(
&mut table_read_completed,
duckdb_snapshot.as_ref(),
cancel_token.clone(),
+ cleanup_error,
)
.await?;
let row_count = result.rows.len();
@@ -2270,7 +2341,8 @@ async fn export_table_data_core_inner(
status: ExportStatus::Cancelled,
error_message: Some("Export cancelled".to_string()),
});
- close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session).await;
+ close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session, cleanup_error)
+ .await;
return Ok(());
}
@@ -2296,6 +2368,7 @@ async fn export_table_data_core_inner(
&mut table_read_completed,
duckdb_snapshot.as_ref(),
cancel_token.clone(),
+ cleanup_error,
)
.await?;
let row_count = result.rows.len();
@@ -2356,7 +2429,8 @@ async fn export_table_data_core_inner(
status: ExportStatus::Cancelled,
error_message: Some("Export cancelled".to_string()),
});
- close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session).await;
+ close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session, cleanup_error)
+ .await;
return Ok(());
}
@@ -2382,6 +2456,7 @@ async fn export_table_data_core_inner(
&mut table_read_completed,
duckdb_snapshot.as_ref(),
cancel_token.clone(),
+ cleanup_error,
)
.await?;
let row_count = result.rows.len();
@@ -2451,7 +2526,7 @@ async fn export_table_data_core_inner(
}
}
- close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session).await;
+ close_table_export_cursor_if_open(state, &pool_key, request, &mut cursor_session, cleanup_error).await;
file.finish(&format!("{}.sql", request.table_name))?;
// 8. Emit Done progress
diff --git a/crates/dbx-core/src/query/mod.rs b/crates/dbx-core/src/query/mod.rs
index 3b7dc5c019..2dfa7edef4 100644
--- a/crates/dbx-core/src/query/mod.rs
+++ b/crates/dbx-core/src/query/mod.rs
@@ -3237,6 +3237,82 @@ pub struct LargeValueRequest {
pub download_encoding: Option<String>,
}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum LargeValueCompletion {
+ Failed,
+ Cancelled,
+ Unknown,
+}
+
+#[derive(Debug, Clone)]
+pub struct LargeValueOperationError {
+ pub status: LargeValueCompletion,
+ pub message: String,
+}
+
+impl std::fmt::Display for LargeValueOperationError {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter.write_str(&self.message)
+ }
+}
+
+impl std::error::Error for LargeValueOperationError {}
+
+impl From<String> for LargeValueOperationError {
+ fn from(message: String) -> Self {
+ Self { status: LargeValueCompletion::Failed, message }
+ }
+}
+
+impl From<&str> for LargeValueOperationError {
+ fn from(message: &str) -> Self {
+ message.to_string().into()
+ }
+}
+
+impl LargeValueOperationError {
+ fn cancelled() -> Self {
+ Self { status: LargeValueCompletion::Cancelled, message: canceled_error() }
+ }
+
+ fn unknown(message: String) -> Self {
+ Self { status: LargeValueCompletion::Unknown, message }
+ }
+
+ fn from_agent(error: AgentCallError) -> Self {
+ use crate::db::agent_driver::AgentErrorCategory;
+ let status = match &error {
+ AgentCallError::Structured { context, .. } if context.category == AgentErrorCategory::Canceled => {
+ LargeValueCompletion::Cancelled
+ }
+ AgentCallError::Structured { .. } | AgentCallError::Legacy { .. } => LargeValueCompletion::Failed,
+ _ => LargeValueCompletion::Unknown,
+ };
+ Self { status, message: error.into_legacy_string() }
+ }
+}
+
+async fn wait_for_large_value_resource<T>(
+ cancel: Option<CancellationToken>,
+ timeout: Option<Duration>,
+ future: impl std::future::Future<Output = T>,
+ report_completion: bool,
+) -> Result<T, LargeValueOperationError> {
+ if !report_completion {
+ return wait_for_value_opt(cancel, timeout, future).await.map_err(Into::into);
+ }
+ if let Some(token) = cancel {
+ tokio::select! {
+ biased;
+ _ = token.cancelled() => Err(LargeValueOperationError::cancelled()),
+ value = wait_for_value_opt(None, timeout, future) => value.map_err(Into::into),
+ }
+ } else {
+ wait_for_value_opt(None, timeout, future).await.map_err(Into::into)
+ }
+}
+
/// Fetches only the original captured locator; never retries by selecting the current row.
pub async fn request_large_value(
state: &AppState,
@@ -3266,53 +3342,126 @@ async fn request_large_value_with_cancel(
release: bool,
cancel_token: Option<CancellationToken>,
) -> Result<serde_json::Value, String> {
+ request_large_value_internal(state, request, release, cancel_token, false).await.map_err(|error| error.message)
+}
+
+pub async fn request_large_value_reported(
+ state: &AppState,
+ request: LargeValueRequest,
+) -> Result<serde_json::Value, LargeValueOperationError> {
+ let registered = request.execution_id.as_ref().map(|id| {
+ state.running_queries.register_task(
+ id.clone(),
+ crate::query_cancel::RunningTaskMetadata::query(
+ request.connection_id.clone(),
+ request.database.clone(),
+ request.client_session_id.clone(),
+ ),
+ )
+ });
+ let cancel = registered.as_ref().map(|task| task.token());
+ request_large_value_internal(state, request, false, cancel, true).await
+}
+
+async fn request_large_value_internal(
+ state: &AppState,
+ request: LargeValueRequest,
+ release: bool,
+ cancel_token: Option<CancellationToken>,
+ report_completion: bool,
+) -> Result<serde_json::Value, LargeValueOperationError> {
if request.value_ref.len() > 128 || (!release && (request.limit == 0 || request.limit > 4096)) {
- return Err("Invalid LOB chunk request".to_string());
+ return Err("Invalid LOB chunk request".into());
}
let method = if release { "release_large_value" } else { "read_large_value_chunk" };
let params = serde_json::json!({ "valueRef": request.value_ref, "offset": request.offset, "limit": request.limit });
let timeout = Some(std::time::Duration::from_secs(30));
if let Some(txn_id) = request.txn_session_id.as_deref() {
let connection = {
- let mut sessions =
- wait_for_value_opt(cancel_token.clone(), timeout, state.transaction_sessions.write()).await?;
+ let mut sessions = wait_for_large_value_resource(
+ cancel_token.clone(),
+ timeout,
+ state.transaction_sessions.write(),
+ report_completion,
+ )
+ .await?;
let session = sessions.get_mut(txn_id).ok_or(MANUAL_TRANSACTION_SESSION_NOT_FOUND_ERROR)?;
if session.connection_id != request.connection_id
|| session.busy
|| session.last_activity.elapsed() >= session.idle_timeout
{
- return Err("LOB transaction context expired or busy".to_string());
+ return Err("LOB transaction context expired or busy".into());
}
session.last_activity = std::time::Instant::now();
Arc::clone(&session.connection)
};
- let connection = wait_for_value_opt(cancel_token.clone(), timeout, connection.lock()).await?;
+ let connection =
+ wait_for_large_value_resource(cancel_token.clone(), timeout, connection.lock(), report_completion).await?;
let result = match &*connection {
TxnConnection::Agent { client, .. } => {
- wait_for_value_opt(cancel_token.clone(), timeout, client.lock())
- .await?
- .call_with_timeout_and_cancel(method, params, timeout, cancel_token.clone())
- .await
+ let mut client =
+ wait_for_large_value_resource(cancel_token.clone(), timeout, client.lock(), report_completion)
+ .await?;
+ if report_completion {
+ if is_canceled(&cancel_token) {
+ return Err(LargeValueOperationError::cancelled());
+ }
+ client
+ .call_typed_with_timeout_and_cancel(method, params, timeout, None)
+ .await
+ .map_err(LargeValueOperationError::from_agent)
+ } else {
+ client
+ .call_with_timeout_and_cancel(method, params, timeout, cancel_token.clone())
+ .await
+ .map_err(Into::into)
+ }
}
TxnConnection::ExternalDriver { session, config, .. } => {
let mut params = params;
params["connection"] = serde_json::json!(config.as_ref());
- wait_for_value_opt(
- cancel_token.clone(),
- timeout,
- session.invoke_with_timeout::<serde_json::Value>(method, params, timeout),
- )
- .await?
+ if report_completion {
+ if is_canceled(&cancel_token) {
+ return Err(LargeValueOperationError::cancelled());
+ }
+ session
+ .invoke_with_timeout::<serde_json::Value>(method, params, timeout)
+ .await
+ .map_err(LargeValueOperationError::unknown)
+ } else {
+ wait_for_value_opt(
+ cancel_token.clone(),
+ timeout,
+ session.invoke_with_timeout::<serde_json::Value>(method, params, timeout),
+ )
+ .await?
+ .map_err(Into::into)
+ }
}
- _ => return Err("LOB snapshot chunks require a supported transaction".to_string()),
+ _ => return Err("LOB snapshot chunks require a supported transaction".into()),
};
+ if report_completion {
+ // An unconfirmed RPC must not become a settled local error after a
+ // concurrent transaction removal or cancellation.
+ let value = result?;
+ if is_canceled(&cancel_token) {
+ return Err(LargeValueOperationError::cancelled());
+ }
+ if !wait_for_large_value_resource(cancel_token, timeout, state.transaction_sessions.read(), true)
+ .await?
+ .contains_key(txn_id)
+ {
+ return Err("LOB transaction context expired".into());
+ }
+ return Ok(value);
+ }
if !wait_for_value_opt(cancel_token, timeout, state.transaction_sessions.read()).await?.contains_key(txn_id) {
- return Err("LOB transaction context expired".to_string());
+ return Err("LOB transaction context expired".into());
}
return result;
}
let pool_database = query_pool_database(&request.database, request.catalog.as_deref());
- let (pool_key, handle) = wait_for_value_opt(
+ let (pool_key, handle) = wait_for_large_value_resource(
cancel_token.clone(),
timeout,
state.existing_workload_pool_for_session(
@@ -3320,26 +3469,57 @@ async fn request_large_value_with_cancel(
pool_database,
request.client_session_id.as_deref(),
),
+ report_completion,
)
.await?
.ok_or_else(|| "LOB context has expired; rerun the query".to_string())?;
let _activity = state.pool_activity_touch(pool_key.as_str());
match handle {
PoolKind::Agent(client) => {
- let mut client = wait_for_value_opt(cancel_token.clone(), timeout, client.lock()).await?;
- client.call_with_timeout_and_cancel(method, params, timeout, cancel_token).await
+ let mut client =
+ wait_for_large_value_resource(cancel_token.clone(), timeout, client.lock(), report_completion).await?;
+ if report_completion {
+ if is_canceled(&cancel_token) {
+ return Err(LargeValueOperationError::cancelled());
+ }
+ let value = client
+ .call_typed_with_timeout_and_cancel(method, params, timeout, None)
+ .await
+ .map_err(LargeValueOperationError::from_agent)?;
+ if is_canceled(&cancel_token) {
+ return Err(LargeValueOperationError::cancelled());
+ }
+ Ok(value)
+ } else {
+ client.call_with_timeout_and_cancel(method, params, timeout, cancel_token).await.map_err(Into::into)
+ }
}
PoolKind::ExternalDriver { session, config, .. } => {
let mut params = params;
params["connection"] = serde_json::json!(config.as_ref());
- wait_for_value_opt(
- cancel_token,
- timeout,
- session.invoke_with_timeout::<serde_json::Value>(method, params, timeout),
- )
- .await?
+ if report_completion {
+ if is_canceled(&cancel_token) {
+ return Err(LargeValueOperationError::cancelled());
+ }
+ let value = session
+ .invoke_with_timeout::<serde_json::Value>(method, params, timeout)
+ .await
+ .map_err(LargeValueOperationError::unknown)?;
+ if is_canceled(&cancel_token) {
+ return Err(LargeValueOperationError::cancelled());
+ }
+ Ok(value)
+ } else {
+ wait_for_value_opt(
+ cancel_token,
+ timeout,
+ session.invoke_with_timeout::<serde_json::Value>(method, params, timeout),
+ )
+ .await?
+ .map_err(Into::into)
+ }
}
- _ => Err("LOB snapshot chunks require a supported connection".to_string()),
+ _ => Err("LOB snapshot chunks require a supported connection".into()),
}
}
diff --git a/crates/dbx-core/src/query/snapshot_export.rs b/crates/dbx-core/src/query/snapshot_export.rs
index e706d517d2..4d6f5b38a3 100644
--- a/crates/dbx-core/src/query/snapshot_export.rs
+++ b/crates/dbx-core/src/query/snapshot_export.rs
@@ -1,4 +1,4 @@
-use super::{canceled_error, is_canceled, request_large_value_with_cancel, LargeValueRequest};
+use super::{is_canceled, request_large_value_internal, LargeValueOperationError, LargeValueRequest};
use crate::connection::AppState;
use serde::Deserialize;
use serde_json::Value;
@@ -33,6 +33,23 @@ pub async fn write_snapshot_export(
request: SnapshotExportRequest,
output: &mut std::fs::File,
) -> Result<(), String> {
+ write_snapshot_export_internal(state, request, output, false).await.map_err(|error| error.message)
+}
+
+pub async fn write_snapshot_export_reported(
+ state: &AppState,
+ request: SnapshotExportRequest,
+ output: &mut std::fs::File,
+) -> Result<(), LargeValueOperationError> {
+ write_snapshot_export_internal(state, request, output, true).await
+}
+
+async fn write_snapshot_export_internal(
+ state: &AppState,
+ request: SnapshotExportRequest,
+ output: &mut std::fs::File,
+ report_completion: bool,
+) -> Result<(), LargeValueOperationError> {
let registered = request.context.execution_id.as_ref().map(|id| {
state.running_queries.register_task(
id.clone(),
@@ -45,7 +62,7 @@ pub async fn write_snapshot_export(
});
let cancel = registered.as_ref().map(|task| task.token());
write_snapshot_export_with_fetch(request, output, cancel.clone(), |chunk_request| {
- request_large_value_with_cancel(state, chunk_request, false, cancel.clone())
+ request_large_value_internal(state, chunk_request, false, cancel.clone(), report_completion)
})
.await
}
@@ -55,10 +72,10 @@ async fn write_snapshot_export_with_fetch<F, Fut>(
output: &mut std::fs::File,
cancel: Option<tokio_util::sync::CancellationToken>,
mut fetch: F,
-) -> Result<(), String>
+) -> Result<(), LargeValueOperationError>
where
F: FnMut(LargeValueRequest) -> Fut,
- Fut: std::future::Future<Output = Result<Value, String>>,
+ Fut: std::future::Future<Output = Result<Value, LargeValueOperationError>>,
{
let mut buffered = std::io::BufWriter::new(output);
let output = &mut buffered;
@@ -101,7 +118,7 @@ where
}
for (row_index, row) in request.rows.iter().enumerate() {
if is_canceled(&cancel) {
- return Err(canceled_error());
+ return Err(LargeValueOperationError::cancelled());
}
output
.write_all(if json {
@@ -131,9 +148,12 @@ where
let mut original_kind: Option<String> = None;
loop {
if is_canceled(&cancel) {
- return Err(canceled_error());
+ return Err(LargeValueOperationError::cancelled());
}
let chunk = fetch(chunk_request.clone()).await?;
+ if is_canceled(&cancel) {
+ return Err(LargeValueOperationError::cancelled());
+ }
let (data, next, eof, kind) = checked_chunk(&chunk, chunk_request.offset)?;
if original_kind.as_deref().is_some_and(|original| original != kind) {
return Err("LOB chunk type changed".into());
@@ -168,7 +188,7 @@ where
let mut buffer = [0_u8; 8192];
loop {
if is_canceled(&cancel) {
- return Err(canceled_error());
+ return Err(LargeValueOperationError::cancelled());
}
let count = cell_file.read(&mut buffer).map_err(|e| e.to_string())?;
if count == 0 {
@@ -197,12 +217,12 @@ where
}
}
if is_canceled(&cancel) {
- return Err(canceled_error());
+ return Err(LargeValueOperationError::cancelled());
}
if json {
output.write_all(b"]").map_err(|e| e.to_string())?;
}
- output.flush().map_err(|e| e.to_string())
+ output.flush().map_err(|error| error.to_string().into())
}
struct CancelableReader<'a, R> {
@@ -212,7 +232,7 @@ struct CancelableReader<'a, R> {
impl<R: Read> Read for CancelableReader<'_, R> {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
if is_canceled(self.cancel) {
- return Err(std::io::Error::other(canceled_error()));
+ return Err(std::io::Error::other(LargeValueOperationError::cancelled()));
}
self.reader.read(buffer)
}
@@ -255,10 +275,18 @@ fn write_escaped(output: &mut impl Write, bytes: &[u8], json: bool) -> Result<()
Ok(())
}
-fn csv_needs_quotes(mut reader: impl Read) -> Result<bool, String> {
+fn snapshot_read_error(error: std::io::Error) -> LargeValueOperationError {
+ error
+ .get_ref()
+ .and_then(|cause| cause.downcast_ref::<LargeValueOperationError>())
+ .cloned()
+ .unwrap_or_else(|| error.to_string().into())
+}
+
+fn csv_needs_quotes(mut reader: impl Read) -> Result<bool, LargeValueOperationError> {
let mut buffer = [0_u8; 8192];
loop {
- let count = reader.read(&mut buffer).map_err(|e| e.to_string())?;
+ let count = reader.read(&mut buffer).map_err(snapshot_read_error)?;
if count == 0 {
return Ok(false);
}
@@ -270,9 +298,9 @@ fn csv_needs_quotes(mut reader: impl Read) -> Result<bool, String> {
// Same cell-level guard as dbx-formats, including negative decimals and literal
// apostrophes, without retaining leading spaces/zeroes or the complete cell.
-fn stream_formula_guard(reader: impl Read) -> Result<bool, String> {
+fn stream_formula_guard(reader: impl Read) -> Result<bool, LargeValueOperationError> {
let mut bytes = BufReader::new(reader).bytes();
- let mut next = || bytes.next().transpose().map_err(|e| e.to_string());
+ let mut next = || bytes.next().transpose().map_err(snapshot_read_error);
let mut byte = next()?;
if byte == Some(b'\'') {
byte = next()?;
@@ -387,7 +415,7 @@ mod tests {
Err(std::io::Error::other("snapshot read failed"))
}
}
- assert_eq!(stream_formula_guard(FailingReader).unwrap_err(), "snapshot read failed");
+ assert_eq!(stream_formula_guard(FailingReader).unwrap_err().message, "snapshot read failed");
}
#[test]
fn escapes_chunk_boundaries_without_changing_utf8_or_binary_hex() {
@@ -471,7 +499,43 @@ mod tests {
} else { serde_json::json!({"status":"expired"}) }))
}).await.unwrap_err();
assert_eq!(calls, if cancel_read { 1 } else { 2 });
- assert!(!error.is_empty());
+ assert!(!error.message.is_empty());
+ }
+ }
+
+ #[tokio::test]
+ async fn reported_writer_waits_for_current_chunk_and_never_overwrites_unknown_with_cancel() {
+ for unknown in [false, true] {
+ let token = tokio_util::sync::CancellationToken::new();
+ let mut file = tempfile::tempfile().unwrap();
+ let (send, receive) = tokio::sync::oneshot::channel();
+ let mut receive = Some(receive);
+ let mut calls = 0;
+ let mut writing =
+ Box::pin(write_snapshot_export_with_fetch(request("json"), &mut file, Some(token.clone()), |_| {
+ calls += 1;
+ let receive = receive.take().expect("A cancelled writer must not request another chunk");
+ async move { receive.await.unwrap() }
+ }));
+ assert!(tokio::time::timeout(std::time::Duration::from_millis(10), &mut writing).await.is_err());
+ token.cancel();
+ assert!(tokio::time::timeout(std::time::Duration::from_millis(10), &mut writing).await.is_err());
+ send.send(if unknown {
+ Err(LargeValueOperationError::unknown("lost original response".into()))
+ } else {
+ Ok(serde_json::json!({"status":"ok","data":"first","next_offset":5,"eof":false,"value_kind":"text"}))
+ })
+ .unwrap();
+ let error = writing.await.unwrap_err();
+ assert_eq!(
+ error.status,
+ if unknown {
+ super::super::LargeValueCompletion::Unknown
+ } else {
+ super::super::LargeValueCompletion::Cancelled
+ }
+ );
+ assert_eq!(calls, 1);
}
}
diff --git a/crates/dbx-core/tests/fixtures/lob_cancel_wait_agent.py b/crates/dbx-core/tests/fixtures/lob_cancel_wait_agent.py
index 4ecf6ba334..1a80870bb0 100644
--- a/crates/dbx-core/tests/fixtures/lob_cancel_wait_agent.py
+++ b/crates/dbx-core/tests/fixtures/lob_cancel_wait_agent.py
@@ -1,6 +1,7 @@
import json
import pathlib
import sys
+import time
log_path = pathlib.Path(sys.argv[1])
print(json.dumps({"ready": True}), flush=True)
@@ -12,6 +13,16 @@ for line in sys.stdin:
if method == "handshake":
result = {"protocolVersion": 2, "agentProtocolVersion": 2, "capabilities": ["multi_session"]}
elif method == "read_large_value_chunk":
+ value_ref = request.get("params", {}).get("valueRef")
+ if value_ref in ("delayed", "delayed-transport"):
+ deadline = time.monotonic() + 5
+ while not log_path.with_suffix(".release").exists() and time.monotonic() < deadline:
+ time.sleep(0.01)
+ if value_ref == "delayed-transport":
+ sys.exit(0)
+ if value_ref == "original-error":
+ print(json.dumps({"jsonrpc": "2.0", "id": request["id"], "error": {"code": -1, "message": "fixture read failed"}}), flush=True)
+ continue
result = {"data": "fixture", "nextOffset": 7, "eof": True, "kind": "text"}
else:
result = {"ok": True}
diff --git a/crates/dbx-core/tests/lob_cancel_wait.rs b/crates/dbx-core/tests/lob_cancel_wait.rs
index b29a276d39..7487930a81 100644
--- a/crates/dbx-core/tests/lob_cancel_wait.rs
+++ b/crates/dbx-core/tests/lob_cancel_wait.rs
@@ -1,7 +1,7 @@
use dbx_core::connection::{AppState, PoolKind, TransactionSession, TxnConnection};
use dbx_core::db::agent_driver::{AgentDriverClient, AgentLaunchSpec, AgentRuntimeClient};
use dbx_core::models::connection::ConnectionConfig;
-use dbx_core::query::{request_large_value, LargeValueRequest};
+use dbx_core::query::{request_large_value, request_large_value_reported, LargeValueCompletion, LargeValueRequest};
use serde_json::json;
use std::sync::Arc;
use std::time::{Duration, Instant};
@@ -130,6 +130,59 @@ async fn public_lob_request_cancels_while_waiting_for_agent_client() {
}
}
+#[tokio::test]
+async fn reported_lob_cancel_during_lock_wait_is_confirmed_without_rpc() {
+ let fixture = Fixture::new().await;
+ let Some(PoolKind::Agent(client)) = fixture.state.pool_handle("lob").await else { panic!("Agent fixture missing") };
+ let _held = client.lock().await;
+ let mut pending = Box::pin(request_large_value_reported(&fixture.state, request(false)));
+ assert!(tokio::time::timeout(Duration::from_millis(20), &mut pending).await.is_err());
+ assert!(fixture.state.running_queries.cancel("lob-wait"));
+ let error = tokio::time::timeout(Duration::from_secs(1), pending).await.unwrap().unwrap_err();
+ assert_eq!(error.status, LargeValueCompletion::Cancelled);
+ fixture.assert_no_lob_rpc();
+}
+
+#[tokio::test]
+async fn reported_lob_cancel_waits_for_original_response_and_preserves_transport_unknown() {
+ for transport in [false, true] {
+ let fixture = Fixture::new().await;
+ let mut req = request(false);
+ req.value_ref = if transport { "delayed-transport" } else { "delayed" }.into();
+ let mut pending = Box::pin(request_large_value_reported(&fixture.state, req));
+ tokio::select! {
+ result = &mut pending => panic!("Read returned before original response: {result:?}"),
+ _ = async {
+ tokio::time::timeout(Duration::from_secs(2), async {
+ loop {
+ let methods = std::fs::read_to_string(fixture.directory.path().join("methods.log")).unwrap_or_default();
+ if methods.lines().any(|method| method == "read_large_value_chunk") { break; }
+ tokio::time::sleep(Duration::from_millis(5)).await;
+ }
+ }).await.unwrap();
+ } => {}
+ }
+ assert!(fixture.state.running_queries.cancel("lob-wait"));
+ assert!(tokio::time::timeout(Duration::from_millis(30), &mut pending).await.is_err());
+ std::fs::write(fixture.directory.path().join("methods.release"), "release").unwrap();
+ let error = tokio::time::timeout(Duration::from_secs(2), pending).await.unwrap().unwrap_err();
+ assert_eq!(
+ error.status,
+ if transport { LargeValueCompletion::Unknown } else { LargeValueCompletion::Cancelled }
+ );
+ }
+}
+
+#[tokio::test]
+async fn reported_lob_original_error_is_a_confirmed_failure() {
+ let fixture = Fixture::new().await;
+ let mut req = request(false);
+ req.value_ref = "original-error".into();
+ let error = request_large_value_reported(&fixture.state, req).await.unwrap_err();
+ assert_eq!(error.status, LargeValueCompletion::Failed);
+ assert!(error.message.contains("fixture read failed"));
+}
+
#[tokio::test]
async fn public_lob_request_cancels_while_preparing_its_pool() {
for release in [false, true] {
diff --git a/src-tauri/src/commands/database_export.rs b/src-tauri/src/commands/database_export.rs
index 6ea35edc98..7f2e593faa 100644
--- a/src-tauri/src/commands/database_export.rs
+++ b/src-tauri/src/commands/database_export.rs
@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
use tauri::{AppHandle, Emitter, State};
use crate::commands::connection::AppState;
@@ -9,6 +9,47 @@ fn emit_progress(app: &AppHandle, progress: ExportProgress) {
let _ = app.emit("database-export-progress", progress);
}
+fn route_core_progress(
+ progress: ExportProgress,
+ terminal: &Mutex<Option<ExportProgress>>,
+ emit: impl FnOnce(ExportProgress),
+) {
+ if matches!(progress.status, ExportStatus::Done | ExportStatus::Error | ExportStatus::Cancelled) {
+ *terminal.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(progress);
+ } else {
+ emit(progress);
+ }
+}
+
+async fn finalize_export(
+ export_id: &str,
+ result: Result<(), String>,
+ terminal: Option<ExportProgress>,
+ close_session: impl std::future::Future<Output = Result<(), String>>,
+ emit: impl FnOnce(ExportProgress),
+) -> Result<(), String> {
+ close_session.await?;
+ dbx_core::database_export::clear_export_cancelled(export_id).await;
+ if let Err(error) = result {
+ emit(ExportProgress {
+ export_id: export_id.to_string(),
+ current_object: String::new(),
+ object_index: 0,
+ total_objects: 0,
+ rows_exported: 0,
+ total_rows: None,
+ status: ExportStatus::Error,
+ error: Some(error),
+ preparing: false,
+ error_count: 0,
+ error_summary: None,
+ });
+ } else if let Some(progress) = terminal {
+ emit(progress);
+ }
+ Ok(())
+}
+
#[tauri::command]
pub async fn begin_database_backup_snapshot(
state: State<'_, Arc<AppState>>,
@@ -37,35 +78,40 @@ pub async fn export_database_sql(
// Exports interleave async fetches with synchronous row formatting and
// buffered disk writes; run them off the async workers (see spawn_export_task).
dbx_core::export_runtime::spawn_export_task(async move {
+ let terminal = Mutex::new(None);
let result = dbx_core::database_export::export_database_sql_core(&state, &request, |progress| {
- emit_progress(&app, progress)
+ route_core_progress(progress, &terminal, |progress| emit_progress(&app, progress));
})
.await;
let client_session_id = dbx_core::database_export::database_export_client_session_id(&export_id);
- let _ =
- state.close_client_session_pool(&request.connection_id, Some(&request.database), &client_session_id).await;
-
- if let Err(e) = result {
- emit_progress(
- &app,
- ExportProgress {
- export_id: export_id.clone(),
- current_object: String::new(),
- object_index: 0,
- total_objects: 0,
- rows_exported: 0,
- total_rows: None,
- status: ExportStatus::Error,
- error: Some(e),
- preparing: false,
- error_count: 0,
- error_summary: None,
- },
+ let terminal = terminal.into_inner().unwrap_or_else(|poisoned| poisoned.into_inner());
+ let completion = finalize_export(
+ &export_id,
+ result,
+ terminal,
+ async {
+ state
+ .close_client_session_pool_with_completion(
+ &request.connection_id,
+ Some(&request.database),
+ &client_session_id,
+ )
+ .await
+ .map(|_| ())
+ },
+ |progress| emit_progress(&app, progress),
+ )
+ .await;
+ if let Err(error) = completion {
+ let _ = app.emit(
+ "database-export-progress",
+ serde_json::json!({
+ "exportId": export_id, "currentObject": "", "objectIndex": 0, "totalObjects": 0,
+ "rowsExported": 0, "totalRows": null, "status": "Unknown", "error": error,
+ }),
);
}
-
- dbx_core::database_export::clear_export_cancelled(&export_id).await;
});
Ok(())
@@ -106,3 +152,86 @@ pub async fn record_database_export_destination(
) -> Result<(), String> {
dbx_core::database_export::record_export_destination_identity(&state, std::path::Path::new(&directory)).await
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn progress(status: ExportStatus) -> ExportProgress {
+ ExportProgress {
+ export_id: "queued-database".to_string(),
+ current_object: "source".to_string(),
+ object_index: 1,
+ total_objects: 1,
+ rows_exported: 1,
+ total_rows: Some(1),
+ status,
+ error: None,
+ preparing: false,
+ error_count: 0,
+ error_summary: None,
+ }
+ }
+
+ #[test]
+ fn forwards_running_progress() {
+ let terminal = Mutex::new(None);
+ let mut emitted = Vec::new();
+ route_core_progress(progress(ExportStatus::Running), &terminal, |progress| emitted.push(progress));
+ assert_eq!(emitted.len(), 1);
+ assert!(terminal.into_inner().unwrap().is_none());
+ }
+
+ #[test]
+ fn holds_terminal_progress_until_session_cleanup() {
+ for status in [ExportStatus::Done, ExportStatus::Error, ExportStatus::Cancelled] {
+ let terminal = Mutex::new(None);
+ route_core_progress(progress(status), &terminal, |_| {
+ panic!("completion must not be emitted before session cleanup");
+ });
+ assert!(terminal.into_inner().unwrap().is_some());
+ }
+ }
+
+ #[tokio::test]
+ async fn finalization_waits_for_the_database_session_to_close() {
+ let (allow_close, closing) = tokio::sync::oneshot::channel();
+ let emitted = std::cell::Cell::new(false);
+ let completion = finalize_export(
+ "queued-database",
+ Ok(()),
+ Some(progress(ExportStatus::Done)),
+ async {
+ closing.await.unwrap();
+ Ok(())
+ },
+ |_| {
+ emitted.set(true);
+ },
+ );
+ tokio::pin!(completion);
+ tokio::select! {
+ _ = &mut completion => panic!("completion must wait for database session cleanup"),
+ _ = tokio::task::yield_now() => {},
+ }
+ assert!(!emitted.get());
+ allow_close.send(()).unwrap();
+ completion.await.unwrap();
+ assert!(emitted.get());
+ }
+
+ #[tokio::test]
+ async fn close_failure_never_emits_a_releasable_terminal() {
+ let emitted = std::cell::Cell::new(false);
+ let result = finalize_export(
+ "queued-database",
+ Ok(()),
+ Some(progress(ExportStatus::Done)),
+ async { Err("session close unknown".to_string()) },
+ |_| emitted.set(true),
+ )
+ .await;
+ assert_eq!(result.unwrap_err(), "session close unknown");
+ assert!(!emitted.get());
+ }
+}
diff --git a/src-tauri/src/commands/mongodb_import_export.rs b/src-tauri/src/commands/mongodb_import_export.rs
index a07a15870a..38f3963526 100644
--- a/src-tauri/src/commands/mongodb_import_export.rs
+++ b/src-tauri/src/commands/mongodb_import_export.rs
@@ -7,8 +7,8 @@ use tokio::sync::RwLock;
use crate::commands::connection::{ensure_connection_writable, AppState};
pub use dbx_core::mongodb_import_export::{
- MongoExportProgress, MongoExportRequest, MongoExportSummary, MongoImportPreview, MongoImportPreviewRequest,
- MongoImportProgress, MongoImportRequest, MongoImportSummary,
+ MongoExportProgress, MongoExportRequest, MongoImportPreview, MongoImportPreviewRequest, MongoImportProgress,
+ MongoImportRequest, MongoImportSummary,
};
static CANCELLED_IMPORTS: OnceLock<RwLock<HashSet<String>>> = OnceLock::new();
@@ -72,7 +72,21 @@ pub async fn export_mongodb_query(
app: AppHandle,
state: State<'_, Arc<AppState>>,
request: MongoExportRequest,
-) -> Result<MongoExportSummary, String> {
+ report_outcome: Option<bool>,
+) -> Result<serde_json::Value, String> {
+ if report_outcome == Some(true) {
+ let outcome = dbx_core::mongodb_import_export::export_mongodb_query_reported(
+ &state,
+ &request,
+ |export_id| {
+ let export_id = export_id.to_string();
+ Box::pin(async move { dbx_core::transfer::is_cancelled(&export_id).await })
+ },
+ |progress| emit_export_progress(&app, progress),
+ )
+ .await;
+ return serde_json::to_value(outcome).map_err(|error| error.to_string());
+ }
dbx_core::mongodb_import_export::export_mongodb_query_core(
&state,
&request,
@@ -83,6 +97,7 @@ pub async fn export_mongodb_query(
|progress| emit_export_progress(&app, progress),
)
.await
+ .and_then(|summary| serde_json::to_value(summary).map_err(|error| error.to_string()))
}
#[tauri::command]
diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rs
index 0c31b030bb..9cf8f0dc66 100644
--- a/src-tauri/src/commands/query.rs
+++ b/src-tauri/src/commands/query.rs
@@ -412,8 +412,22 @@ pub async fn close_query_session(
pub async fn read_large_value_chunk(
state: State<'_, Arc<AppState>>,
request: dbx_core::query::LargeValueRequest,
+ report_outcome: Option<bool>,
) -> Result<serde_json::Value, String> {
- dbx_core::query::request_large_value(&state, request, false).await
+ if report_outcome == Some(true) {
+ Ok(snapshot_outcome(dbx_core::query::request_large_value_reported(&state, request).await))
+ } else {
+ dbx_core::query::request_large_value(&state, request, false).await
+ }
+}
+
+fn snapshot_outcome<T: serde::Serialize>(
+ result: Result<T, dbx_core::query::LargeValueOperationError>,
+) -> serde_json::Value {
+ match result {
+ Ok(value) => serde_json::json!({"status": "succeeded", "value": value}),
+ Err(error) => serde_json::json!({"status": error.status, "message": error.message}),
+ }
}
#[tauri::command]
@@ -445,8 +459,12 @@ pub async fn close_client_connection_session(
database: String,
client_session_id: String,
catalog: Option<String>,
+ report_completion: Option<bool>,
) -> Result<bool, String> {
let database = query_session_database(&database, catalog.as_deref());
+ if report_completion == Some(true) {
+ return state.close_client_session_pool_with_completion(&connection_id, database, &client_session_id).await;
+ }
state.close_client_session_pool(&connection_id, database, &client_session_id).await
}
@@ -455,13 +473,52 @@ pub async fn export_snapshot_result(
state: State<'_, Arc<AppState>>,
request: dbx_core::query::snapshot_export::SnapshotExportRequest,
file_path: String,
-) -> Result<(), String> {
+ report_outcome: Option<bool>,
+) -> Result<serde_json::Value, String> {
+ if report_outcome == Some(true) {
+ return Ok(snapshot_outcome(write_reported_snapshot(&state, request, &file_path).await));
+ }
let path = std::path::Path::new(&file_path);
let parent = path.parent().filter(|parent| !parent.as_os_str().is_empty()).unwrap_or(std::path::Path::new("."));
let mut temporary = tempfile::NamedTempFile::new_in(parent).map_err(|error| error.to_string())?;
dbx_core::query::snapshot_export::write_snapshot_export(&state, request, temporary.as_file_mut()).await?;
temporary.persist(path).map_err(|error| error.to_string())?;
- Ok(())
+ Ok(serde_json::Value::Null)
+}
+
+async fn write_reported_snapshot(
+ state: &AppState,
+ request: dbx_core::query::snapshot_export::SnapshotExportRequest,
+ file_path: &str,
+) -> Result<(), dbx_core::query::LargeValueOperationError> {
+ use dbx_core::query::{LargeValueCompletion, LargeValueOperationError};
+ let path = std::path::Path::new(file_path);
+ let parent = path.parent().filter(|parent| !parent.as_os_str().is_empty()).unwrap_or(std::path::Path::new("."));
+ let mut temporary = tempfile::NamedTempFile::new_in(parent).map_err(|error| error.to_string())?;
+ if let Err(error) =
+ dbx_core::query::snapshot_export::write_snapshot_export_reported(state, request, temporary.as_file_mut()).await
+ {
+ return match temporary.close() {
+ Ok(()) => Err(error),
+ Err(cleanup) => Err(LargeValueOperationError {
+ status: LargeValueCompletion::Unknown,
+ message: format!("{}; snapshot cleanup failed: {cleanup}", error.message),
+ }),
+ };
+ }
+ match temporary.persist(path) {
+ Ok(_) => Ok(()),
+ Err(error) => {
+ let message = error.error.to_string();
+ match error.file.close() {
+ Ok(()) => Err(message.into()),
+ Err(cleanup) => Err(LargeValueOperationError {
+ status: LargeValueCompletion::Unknown,
+ message: format!("{message}; snapshot cleanup failed: {cleanup}"),
+ }),
+ }
+ }
+ }
}
fn query_session_database<'a>(database: &'a str, catalog: Option<&str>) -> Option<&'a str> {
@@ -1323,6 +1380,57 @@ mod tests {
Arc::new(AppState::new_with_plugin_dir(storage, dir.join("plugins")))
}
+ fn snapshot_request(format: &str) -> dbx_core::query::snapshot_export::SnapshotExportRequest {
+ serde_json::from_value(serde_json::json!({
+ "context": {"connectionId":"original", "database":"APP", "valueRef":""},
+ "format": format, "columns":["C"], "rows":[["complete"]], "cells":[]
+ }))
+ .unwrap()
+ }
+
+ #[tokio::test]
+ async fn reported_snapshot_publishes_success_and_cleans_failed_staging_before_reply() {
+ let state = test_app_state().await;
+ let directory = tempfile::tempdir().unwrap();
+ let path = directory.path().join("result.json");
+ let result = write_reported_snapshot(&state, snapshot_request("json"), path.to_str().unwrap()).await;
+ assert_eq!(snapshot_outcome(result), serde_json::json!({"status":"succeeded","value":null}));
+ assert_eq!(
+ serde_json::from_slice::<serde_json::Value>(&std::fs::read(&path).unwrap()).unwrap(),
+ serde_json::json!([{"C":"complete"}])
+ );
+ let result = write_reported_snapshot(&state, snapshot_request("unsupported"), path.to_str().unwrap()).await;
+ assert_eq!(snapshot_outcome(result)["status"], "failed");
+ assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 1);
+ assert_eq!(
+ serde_json::from_slice::<serde_json::Value>(&std::fs::read(&path).unwrap()).unwrap(),
+ serde_json::json!([{"C":"complete"}])
+ );
+ // A following operation owns this path only after the failed staged file is gone.
+ write_reported_snapshot(&state, snapshot_request("csv"), path.to_str().unwrap()).await.unwrap();
+ assert!(std::fs::read_to_string(path).unwrap().contains("complete"));
+ assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 1);
+ }
+
+ #[tokio::test]
+ async fn reported_snapshot_preserves_existing_target_on_persist_failure() {
+ let state = test_app_state().await;
+ let directory = tempfile::tempdir().unwrap();
+ let target = directory.path().join("existing-directory");
+ std::fs::create_dir(&target).unwrap();
+ let result = write_reported_snapshot(&state, snapshot_request("json"), target.to_str().unwrap()).await;
+ assert_eq!(snapshot_outcome(result)["status"], "failed");
+ assert!(target.is_dir());
+ assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 1);
+ let result = write_reported_snapshot(
+ &state,
+ snapshot_request("json"),
+ target.join("missing/result.json").to_str().unwrap(),
+ )
+ .await;
+ assert_eq!(snapshot_outcome(result)["status"], "failed");
+ }
+
#[tokio::test]
async fn execute_script_with_2pc_returns_structured_result() {
let state = test_app_state().await;
diff --git a/src-tauri/src/commands/query_result_export.rs b/src-tauri/src/commands/query_result_export.rs
index 561f88810d..faf9ed84dd 100644
--- a/src-tauri/src/commands/query_result_export.rs
+++ b/src-tauri/src/commands/query_result_export.rs
@@ -98,11 +98,11 @@ fn finalize_staged_export(
cancellation_requested: bool,
rows_exported: u64,
emit: impl Fn(TableExportProgress),
-) {
+) -> Result<(), String> {
if cancellation_requested
|| terminal.as_ref().is_some_and(|progress| matches!(progress.status, ExportStatus::Cancelled))
{
- drop(target);
+ target.discard()?;
let cancelled =
terminal.filter(|progress| matches!(progress.status, ExportStatus::Cancelled)).unwrap_or_else(|| {
TableExportProgress {
@@ -115,29 +115,32 @@ fn finalize_staged_export(
}
});
emit(cancelled);
- return;
+ return Ok(());
}
if let Err(error) = result {
- drop(target);
+ target.discard()?;
emit(export_error_progress(export_id, rows_exported, error));
- return;
+ return Ok(());
}
let Some(done) = terminal.filter(|progress| matches!(progress.status, ExportStatus::Done)) else {
- drop(target);
+ target.discard()?;
emit(export_error_progress(
export_id,
rows_exported,
"Export finished without a completion status".to_string(),
));
- return;
+ return Ok(());
};
- match target.commit() {
+ let completion = target.commit_with_completion();
+ completion.cleanup?;
+ match completion.result {
Ok(()) => emit(done),
Err(error) => emit(export_error_progress(export_id, rows_exported, error)),
}
+ Ok(())
}
#[cfg(test)]
@@ -217,7 +220,8 @@ mod tests {
true,
routed.rows_exported(),
|progress| emitted.lock().expect("emitted lock").push(progress),
- );
+ )
+ .expect("finalize cancellation");
assert!(matches!(
emitted.lock().expect("emitted lock").as_slice(),
@@ -247,7 +251,8 @@ mod tests {
finalize_staged_export(target, "export-1", Err("write failed".to_string()), None, false, 3, |progress| {
emitted.lock().expect("emitted lock").push(progress);
- });
+ })
+ .expect("finalize failure");
assert!(matches!(
emitted.lock().expect("emitted lock").as_slice(),
@@ -256,6 +261,33 @@ mod tests {
assert_eq!(std::fs::read_to_string(destination).expect("read destination"), "original");
}
+ #[test]
+ fn staged_cleanup_failure_does_not_emit_a_releasable_terminal() {
+ for commit in [false, true] {
+ let dir = TestDir::new();
+ let destination = dir.path().join("result.csv");
+ let target = StagedExportTarget::new(destination.to_str().expect("destination path")).expect("target");
+ let staged = target.path().to_path_buf();
+ std::fs::remove_file(&staged).expect("remove staged file");
+ std::fs::create_dir(&staged).expect("block file cleanup");
+ let emitted = Mutex::new(Vec::new());
+ let result = finalize_staged_export(
+ target,
+ "export-1",
+ if commit { Ok(()) } else { Err("read failed".to_string()) },
+ commit.then(|| terminal_progress(ExportStatus::Done, 3)),
+ false,
+ 3,
+ |progress| {
+ emitted.lock().expect("emitted lock").push(progress);
+ },
+ );
+ assert!(result.is_err());
+ assert!(emitted.lock().expect("emitted lock").is_empty());
+ std::fs::remove_dir(staged).expect("remove cleanup blocker");
+ }
+ }
+
#[test]
fn replace_failure_preserves_existing_destination_and_suppresses_done() {
let dir = TestDir::new();
@@ -274,7 +306,8 @@ mod tests {
false,
4,
|progress| emitted.lock().expect("emitted lock").push(progress),
- );
+ )
+ .expect("finalize replacement failure");
assert!(matches!(
emitted.lock().expect("emitted lock").as_slice(),
@@ -312,7 +345,7 @@ pub async fn start_query_result_export(
let cancel_token = registered_query.as_ref().map(|query| query.token());
let routed_progress = Arc::new(RoutedExportProgress::default());
let routed_progress_handler = routed_progress.clone();
- let result = dbx_core::query_result_export::export_query_result_core(
+ let completion = dbx_core::query_result_export::export_query_result_core_with_completion(
&state,
&request,
cancel_token.clone(),
@@ -329,15 +362,30 @@ pub async fn start_query_result_export(
terminal.as_ref().is_some_and(|progress| matches!(progress.status, ExportStatus::Cancelled))
|| cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
|| dbx_core::database_export::is_export_cancelled(&export_id).await;
- finalize_staged_export(
- target,
- &export_id,
- result,
- terminal,
- cancellation_requested,
- routed_progress.rows_exported(),
- |progress| emit_progress(&app, progress),
- );
+ let result = if let Err(error) = completion.cleanup {
+ let _ = target.discard();
+ Err(error)
+ } else {
+ finalize_staged_export(
+ target,
+ &export_id,
+ completion.result,
+ terminal,
+ cancellation_requested,
+ routed_progress.rows_exported(),
+ |progress| emit_progress(&app, progress),
+ )
+ };
+ if let Err(error) = result {
+ let _ = app.emit(
+ "query-result-export-progress",
+ serde_json::json!({
+ "exportId": export_id, "tableName": "Query Result",
+ "rowsExported": routed_progress.rows_exported(), "totalRows": null,
+ "status": "Unknown", "errorMessage": error,
+ }),
+ );
+ }
dbx_core::database_export::clear_export_cancelled(&export_id).await;
});
diff --git a/src-tauri/src/commands/table_export.rs b/src-tauri/src/commands/table_export.rs
index 57f007ba20..c98db4a05b 100644
--- a/src-tauri/src/commands/table_export.rs
+++ b/src-tauri/src/commands/table_export.rs
@@ -1,7 +1,4 @@
-use std::sync::{
- atomic::{AtomicBool, Ordering},
- Arc,
-};
+use std::sync::{Arc, Mutex};
use tauri::{AppHandle, Emitter, State};
use crate::commands::connection::AppState;
@@ -12,11 +9,57 @@ fn emit_progress(app: &AppHandle, progress: TableExportProgress) {
let _ = app.emit("table-export-progress", progress);
}
-async fn remove_incomplete_export(file_path: &str, failed: bool, cancelled: bool) {
+fn route_core_progress(
+ progress: TableExportProgress,
+ terminal: &Mutex<Option<TableExportProgress>>,
+ emit: impl FnOnce(TableExportProgress),
+) {
+ if matches!(progress.status, ExportStatus::Done | ExportStatus::Error | ExportStatus::Cancelled) {
+ *terminal.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(progress);
+ } else {
+ emit(progress);
+ }
+}
+
+async fn remove_incomplete_export(file_path: &str, failed: bool, cancelled: bool) -> Result<(), String> {
// A cancelled core export returns Ok, so cleanup must also follow the emitted terminal status.
if failed || cancelled {
- let _ = tokio::fs::remove_file(file_path).await;
+ match tokio::fs::remove_file(file_path).await {
+ Ok(()) => {}
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+ Err(error) => return Err(error.to_string()),
+ }
+ }
+ Ok(())
+}
+
+async fn finalize_export(
+ export_id: &str,
+ file_path: &str,
+ result: Result<(), String>,
+ terminal: Option<TableExportProgress>,
+ close_session: impl std::future::Future<Output = Result<(), String>>,
+ emit: impl FnOnce(TableExportProgress),
+) -> Result<(), String> {
+ let close_result = close_session.await;
+ let was_cancelled = terminal.as_ref().is_some_and(|progress| matches!(progress.status, ExportStatus::Cancelled));
+ let remove_result = remove_incomplete_export(file_path, result.is_err(), was_cancelled).await;
+ close_result?;
+ remove_result?;
+ dbx_core::database_export::clear_export_cancelled(export_id).await;
+ if let Err(error) = result {
+ emit(TableExportProgress {
+ export_id: export_id.to_string(),
+ table_name: String::new(),
+ rows_exported: 0,
+ total_rows: None,
+ status: ExportStatus::Error,
+ error_message: Some(error),
+ });
+ } else if let Some(progress) = terminal {
+ emit(progress);
}
+ Ok(())
}
#[tauri::command]
@@ -32,39 +75,31 @@ pub async fn start_table_export(
// Exports interleave async fetches with synchronous row formatting and
// buffered disk writes; run them off the async workers (see spawn_export_task).
dbx_core::export_runtime::spawn_export_task(async move {
- let cancelled = Arc::new(AtomicBool::new(false));
- let cancelled_progress = cancelled.clone();
- let result = dbx_core::table_export::export_table_data_core(&state, &request, |progress| {
- if matches!(progress.status, ExportStatus::Cancelled) {
- cancelled_progress.store(true, Ordering::SeqCst);
- }
- emit_progress(&app, progress);
+ let terminal = Mutex::new(None);
+ let completion = dbx_core::table_export::export_table_data_core_with_completion(&state, &request, |progress| {
+ route_core_progress(progress, &terminal, |progress| emit_progress(&app, progress));
})
.await;
- let client_session_id = dbx_core::table_export::table_export_client_session_id(&export_id);
- let _ =
- state.close_client_session_pool(&request.connection_id, Some(&request.database), &client_session_id).await;
-
- let failed = result.is_err();
- let was_cancelled = cancelled.load(Ordering::SeqCst);
- remove_incomplete_export(&file_path, failed, was_cancelled).await;
-
- if let Err(e) = result {
- emit_progress(
- &app,
- TableExportProgress {
- export_id: export_id.clone(),
- table_name: String::new(),
- rows_exported: 0,
- total_rows: None,
- status: ExportStatus::Error,
- error_message: Some(e),
- },
+ let terminal = terminal.into_inner().unwrap_or_else(|poisoned| poisoned.into_inner());
+ let completion = finalize_export(
+ &export_id,
+ &file_path,
+ completion.result,
+ terminal,
+ async { completion.cleanup },
+ |progress| emit_progress(&app, progress),
+ )
+ .await;
+ if let Err(error) = completion {
+ let _ = app.emit(
+ "table-export-progress",
+ serde_json::json!({
+ "exportId": export_id, "tableName": request.table_name,
+ "rowsExported": 0, "totalRows": null, "status": "Unknown", "errorMessage": error,
+ }),
);
}
-
- dbx_core::database_export::clear_export_cancelled(&export_id).await;
});
Ok(())
@@ -78,7 +113,89 @@ pub async fn cancel_table_export(export_id: String) -> Result<(), String> {
#[cfg(test)]
mod tests {
- use super::remove_incomplete_export;
+ use super::*;
+
+ fn progress(status: ExportStatus) -> TableExportProgress {
+ TableExportProgress {
+ export_id: "queued-export".to_string(),
+ table_name: "source".to_string(),
+ rows_exported: 1,
+ total_rows: Some(1),
+ status,
+ error_message: None,
+ }
+ }
+
+ #[test]
+ fn forwards_nonterminal_progress_without_releasing_completion() {
+ let terminal = Mutex::new(None);
+ let mut emitted = Vec::new();
+ route_core_progress(progress(ExportStatus::Running), &terminal, |progress| emitted.push(progress));
+ assert_eq!(emitted.len(), 1);
+ assert!(terminal.into_inner().unwrap().is_none());
+ }
+
+ #[tokio::test]
+ async fn holds_cancelled_progress_while_removing_partial_file() {
+ let path = create_export_file("deferred-terminal").await;
+ let terminal = Mutex::new(None);
+ route_core_progress(progress(ExportStatus::Cancelled), &terminal, |_| {
+ panic!("completion must not be emitted before cleanup");
+ });
+
+ assert!(path.exists());
+ remove_incomplete_export(path.to_str().unwrap(), false, true).await.unwrap();
+ assert!(!path.exists());
+ assert!(matches!(terminal.into_inner().unwrap().unwrap().status, ExportStatus::Cancelled));
+ }
+
+ #[tokio::test]
+ async fn completes_cleanup_before_starting_the_next_export_at_the_same_path() {
+ let path = create_export_file("same-path").await;
+ let (allow_close, closing) = tokio::sync::oneshot::channel();
+ let emitted = std::cell::Cell::new(false);
+ let next_path = path.clone();
+ let terminal = Mutex::new(None);
+ route_core_progress(progress(ExportStatus::Cancelled), &terminal, |_| panic!("early terminal"));
+ let completion = finalize_export(
+ "queued-export",
+ path.to_str().unwrap(),
+ Ok(()),
+ terminal.into_inner().unwrap(),
+ async {
+ closing.await.unwrap();
+ Ok(())
+ },
+ |_| {
+ assert!(!next_path.exists());
+ std::fs::write(&next_path, b"next export").unwrap();
+ emitted.set(true);
+ },
+ );
+ tokio::pin!(completion);
+ tokio::select! {
+ _ = &mut completion => panic!("completion must wait for session cleanup"),
+ _ = tokio::task::yield_now() => {},
+ }
+ assert!(!emitted.get());
+ assert_eq!(tokio::fs::read(&path).await.unwrap(), b"partial export");
+ allow_close.send(()).unwrap();
+ completion.await.unwrap();
+ assert!(emitted.get());
+ assert_eq!(tokio::fs::read(&path).await.unwrap(), b"next export");
+ tokio::fs::remove_file(&path).await.unwrap();
+ }
+
+ #[test]
+ fn holds_success_and_error_progress_until_finalization() {
+ for status in [ExportStatus::Done, ExportStatus::Error] {
+ let terminal = Mutex::new(None);
+ route_core_progress(progress(status), &terminal, |_| {
+ panic!("completion must not be emitted before cleanup");
+ });
+ assert!(terminal.into_inner().unwrap().is_some());
+ }
+ }
async fn create_export_file(name: &str) -> std::path::PathBuf {
let path = std::env::temp_dir().join(format!("dbx-table-export-{name}-{}", uuid::Uuid::new_v4()));
@@ -90,7 +207,7 @@ mod tests {
async fn removes_export_file_after_cancellation() {
let path = create_export_file("cancelled").await;
- remove_incomplete_export(path.to_str().unwrap(), false, true).await;
+ remove_incomplete_export(path.to_str().unwrap(), false, true).await.unwrap();
assert!(!path.exists());
}
@@ -99,7 +216,7 @@ mod tests {
async fn removes_export_file_after_error() {
let path = create_export_file("failed").await;
- remove_incomplete_export(path.to_str().unwrap(), true, false).await;
+ remove_incomplete_export(path.to_str().unwrap(), true, false).await.unwrap();
assert!(!path.exists());
}
@@ -108,9 +225,42 @@ mod tests {
async fn preserves_successful_export_file() {
let path = create_export_file("completed").await;
- remove_incomplete_export(path.to_str().unwrap(), false, false).await;
+ remove_incomplete_export(path.to_str().unwrap(), false, false).await.unwrap();
assert!(path.exists());
tokio::fs::remove_file(path).await.unwrap();
}
+
+ #[tokio::test]
+ async fn cleanup_failure_never_emits_a_releasable_terminal() {
+ let emitted = std::cell::Cell::new(false);
+ let path = create_export_file("close-failed").await;
+ let result = finalize_export(
+ "queued-export",
+ path.to_str().unwrap(),
+ Ok(()),
+ Some(progress(ExportStatus::Cancelled)),
+ async { Err("session close unknown".to_string()) },
+ |_| emitted.set(true),
+ )
+ .await;
+ assert_eq!(result.unwrap_err(), "session close unknown");
+ assert!(!emitted.get());
+ assert!(!path.exists());
+
+ let directory = std::env::temp_dir().join(format!("dbx-delete-failure-{}", uuid::Uuid::new_v4()));
+ tokio::fs::create_dir(&directory).await.unwrap();
+ let result = finalize_export(
+ "queued-export",
+ directory.to_str().unwrap(),
+ Err("write failed".to_string()),
+ None,
+ async { Ok(()) },
+ |_| emitted.set(true),
+ )
+ .await;
+ assert!(result.is_err());
+ assert!(!emitted.get());
+ tokio::fs::remove_dir(directory).await.unwrap();
+ }
}