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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
import { strict as assert } from "node:assert";
import { computed, ref } from "vue";
import { beforeEach, test, vi } from "vitest";
import { createPinia, setActivePinia } from "pinia";
import { useSettingsStore } from "../../apps/desktop/src/stores/settingsStore.ts";
import type { DataGridTableMeta } from "../../apps/desktop/src/lib/dataGrid/dataGridSql.ts";
import { DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS, type DataGridExtractorOptions } from "../../apps/desktop/src/lib/dataGrid/dataGridCopyExtractor.ts";
import type { DatabaseType, QueryResult } from "../../apps/desktop/src/types/database.ts";
const apiMock = vi.hoisted(() => ({
startQueryResultExport: vi.fn(),
cancelQueryResultExport: vi.fn(),
startTableExport: vi.fn(),
cancelTableExport: vi.fn(),
saveEditorSettings: vi.fn(async () => {}),
exportQueryResultCsv: vi.fn(),
exportQueryResultXlsx: vi.fn(),
exportQueryResultJson: vi.fn(),
exportQueryResultMarkdown: vi.fn(),
exportQueryResultsXlsx: vi.fn(),
buildDataGridCopyInsertStatement: vi.fn(),
buildExportSqlInsert: vi.fn(),
}));
const clipboardMock = vi.hoisted(() => ({
copyToClipboard: vi.fn(),
}));
const runtimeMock = vi.hoisted(() => ({ isTauri: false }));
const sqlInsertModeMock = vi.hoisted(() => ({ showSqlInsertModeDialog: vi.fn() }));
const dialogMock = vi.hoisted(() => ({ save: vi.fn() }));
const toastMock = vi.hoisted(() => vi.fn());
const translateMock = vi.hoisted(() =>
vi.fn((key: string, params?: Record<string, unknown>) => {
if (key === "exportProgress.streamingUnsupported") return "当前查询暂不支持流式导出,请简化查询或使用受支持的驱动。";
if (key === "grid.exportFailed") return `导出失败:${params?.message}`;
return key;
}),
);
vi.mock("@/lib/backend/api", () => apiMock);
vi.mock("@/lib/export/sqlInsertMode", () => sqlInsertModeMock);
vi.mock("@/lib/common/clipboard", () => clipboardMock);
vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => runtimeMock.isTauri }));
vi.mock("@tauri-apps/plugin-dialog", () => ({ save: dialogMock.save }));
vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: toastMock }) }));
vi.mock("vue-i18n", () => ({
createI18n: () => ({
global: {
locale: { value: "en" },
setLocaleMessage: vi.fn(),
},
install: vi.fn(),
}),
useI18n: () => ({ t: translateMock }),
}));
const { defaultDataGridExportFileName, useDataGridExport } = await import("../../apps/desktop/src/composables/useDataGridExport.ts");
function installMemoryStorage() {
const values = new Map<string, string>();
const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
Object.defineProperty(globalThis, "localStorage", {
configurable: true,
value: {
getItem: (key: string) => values.get(key) ?? null,
setItem: (key: string, value: string) => values.set(key, value),
removeItem: (key: string) => values.delete(key),
clear: () => values.clear(),
},
});
return () => {
if (original) Object.defineProperty(globalThis, "localStorage", original);
else Reflect.deleteProperty(globalThis, "localStorage");
};
}
function installTextDownloadCapture() {
let downloadedBlob: Blob | undefined;
const createObjectUrl = vi.spyOn(URL, "createObjectURL").mockImplementation((blob) => {
downloadedBlob = blob;
return "blob:test-export";
});
const revokeObjectUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
const originalDocument = Object.getOwnPropertyDescriptor(globalThis, "document");
Object.defineProperty(globalThis, "document", {
configurable: true,
value: { createElement: () => ({ click: vi.fn(), href: "", download: "" }) },
});
return {
content: async () => downloadedBlob?.text(),
restore: () => {
createObjectUrl.mockRestore();
revokeObjectUrl.mockRestore();
if (originalDocument) Object.defineProperty(globalThis, "document", originalDocument);
else Reflect.deleteProperty(globalThis, "document");
},
};
}
function buildExportHarness(
options: {
currentResultLabel?: string;
exportFileBaseName?: string;
columns?: string[];
columnTypes?: Array<string | undefined>;
allColumnTypes?: Array<string | undefined>;
rows?: QueryResult["rows"];
allExportResults?: Array<{ sheetName: string; result: QueryResult; sql?: string }>;
completeLocalResult?: QueryResult;
tableMeta?: DataGridTableMeta;
sourceColumns?: Array<string | undefined>;
databaseType?: DatabaseType;
context?: "results" | "table-data";
extractorOptions?: DataGridExtractorOptions;
sql?: string;
exportSql?: string;
pageSql?: string;
displayValue?: (value: any, columnIndex: number) => string;
hasColumnFormatter?: (columnIndex: number) => boolean;
applyColumnFormattersOnExport?: any;
contextCell?: any;
} = {},
) {
const exportColumns = options.columns ?? ["id", "name"];
const exportRows = options.rows ?? [
[1, "Ada"],
[2, "Lin"],
];
const rowItems = exportRows.map((data, index) => ({ id: index + 1, data, isNew: false, isDeleted: false, isDirtyCol: data.map(() => false), status: "" }));
const contextCell = options.contextCell ?? ref(null);
const exportProgressDialog = ref(false);
const exportProgressState = ref({
title: "",
tableName: "",
format: "csv",
rowsExported: 0,
totalRows: null as number | null,
status: "",
errorMessage: null as string | null,
filePath: null as string | null,
});
const exportCancelHandler = ref<(() => Promise<void>) | null>(null);
const fullExportResult = vi.fn(async () => {
throw new Error("fullExportResult should not be called for streaming CSV/XLSX query exports");
});
const queryResultExportRequest = vi.fn(async (options: { exportId: string; filePath: string; format: "csv" | "xlsx" | "txt" | "sql"; includeSqlSheet?: boolean; exportTableName?: string; exportColumnTypes?: Array<string | null | undefined>; insertMode?: "batch" | "single" }) => ({
exportId: options.exportId,
connectionId: "conn-1",
database: "db",
schema: "public",
sql: "SELECT * FROM users",
queryBaseSql: "SELECT * FROM users",
databaseType: "postgres" as const,
useAgentCursor: false,
filePath: options.filePath,
format: options.format,
includeSqlSheet: options.includeSqlSheet,
exportTableName: options.exportTableName,
exportColumnTypes: options.exportColumnTypes,
...(options.insertMode ? { insertMode: options.insertMode } : {}),
pageSize: 1000,
rowLimit: 100000,
totalRows: 2,
timeoutSecs: 30,
keysetOptimizationEnabled: true,
clientSessionId: "tab-1:export",
executionId: "exec-1",
}));
const composable = useDataGridExport({
columns: computed(() => exportColumns),
displayItems: computed(() => rowItems),
sql: computed(() => options.sql ?? "SELECT * FROM users"),
exportSql: computed(() => options.exportSql ?? "SELECT * FROM users ORDER BY id DESC"),
pageSql: computed(() => options.pageSql),
tableMeta: computed(() => options.tableMeta),
databaseType: computed(() => options.databaseType ?? "postgres"),
connectionId: computed(() => "conn-1"),
database: computed(() => "db"),
context: computed(() => options.context ?? "results"),
extractorOptions: computed(() => options.extractorOptions),
sourceColumns: computed(() => options.sourceColumns),
columnTypes: computed(() => options.columnTypes),
allColumnTypes: computed(() => options.allColumnTypes),
whereInput: computed(() => undefined),
orderBy: computed(() => undefined),
exportBatchSize: computed(() => 1000),
hasCellSelection: computed(() => false),
selectedCells: computed(() => ({ columns: [], rows: [] })),
selectedRange: computed(() => null),
contextCell,
getRowItem: (rowId: number) => rowItems.find((item) => item.id === rowId),
selectedRowIds: ref(new Set<number>()),
hasRowSelection: computed(() => false),
fullExportResult,
queryResultExportRequest,
hasCompleteLocalResult: computed(() => !!options.completeLocalResult),
completeLocalResult: computed(() => options.completeLocalResult),
allExportResults: computed(() => options.allExportResults),
currentResultLabel: computed(() => options.currentResultLabel),
exportFileBaseName: computed(() => options.exportFileBaseName),
displayValue: options.displayValue,
hasColumnFormatter: options.hasColumnFormatter,
applyColumnFormattersOnExport: options.applyColumnFormattersOnExport,
exportProgressDialog,
exportProgressState,
exportCancelHandler,
});
return {
composable,
fullExportResult,
queryResultExportRequest,
exportProgressDialog,
exportProgressState,
exportCancelHandler,
contextCell,
};
}
function buildTableDataExportHarness(
options: {
displayValue?: (value: any, columnIndex: number) => string;
hasColumnFormatter?: (columnIndex: number) => boolean;
applyColumnFormattersOnExport?: any;
fullExportResult?: any;
} = {},
) {
const exportProgressDialog = ref(false);
const exportProgressState = ref({
title: "",
tableName: "",
format: "csv",
rowsExported: 0,
totalRows: null as number | null,
status: "",
errorMessage: null as string | null,
filePath: null as string | null,
});
const exportCancelHandler = ref<(() => Promise<void>) | null>(null);
const composable = useDataGridExport({
columns: computed(() => ["id", "name"]),
displayItems: computed(() => [
{ id: 1, data: [1, "Ada"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
{ id: 2, data: [2, "Lin"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
]),
sql: computed(() => undefined),
tableMeta: computed(() => ({
schema: "public",
tableName: "users",
columns: [
{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
{ name: "name", data_type: "text", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
],
primaryKeys: ["id"],
})),
databaseType: computed(() => "postgres"),
connectionId: computed(() => "conn-1"),
database: computed(() => "db"),
context: computed(() => "table-data"),
sourceColumns: computed(() => undefined),
columnTypes: computed(() => ["integer", "text"]),
whereInput: computed(() => undefined),
orderBy: computed(() => undefined),
exportBatchSize: computed(() => 1000),
hasCellSelection: computed(() => false),
selectedCells: computed(() => ({ columns: [], rows: [] })),
selectedRange: computed(() => null),
contextCell: ref(null),
getRowItem: () => undefined,
selectedRowIds: ref(new Set<number>()),
hasRowSelection: computed(() => false),
fullExportResult: options.fullExportResult,
displayValue: options.displayValue,
hasColumnFormatter: options.hasColumnFormatter,
applyColumnFormattersOnExport: options.applyColumnFormattersOnExport,
exportProgressDialog,
exportProgressState,
exportCancelHandler,
});
return {
composable,
exportProgressDialog,
exportProgressState,
exportCancelHandler,
};
}
beforeEach(() => {
setActivePinia(createPinia());
vi.clearAllMocks();
runtimeMock.isTauri = false;
dialogMock.save.mockResolvedValue(null);
sqlInsertModeMock.showSqlInsertModeDialog.mockResolvedValue("batch");
clipboardMock.copyToClipboard.mockResolvedValue(undefined);
apiMock.startQueryResultExport.mockImplementation(async (_request, onProgress) => {
onProgress({ exportId: _request.exportId, tableName: "", rowsExported: 2, totalRows: 2, status: "Done" });
return { exportId: _request.exportId, tableName: "", rowsExported: 2, totalRows: 2, status: "Done" };
});
apiMock.startTableExport.mockImplementation(async (_request, onProgress) => {
onProgress({ exportId: _request.exportId, tableName: _request.tableName, rowsExported: 2, totalRows: 2, status: "Done" });
return { exportId: _request.exportId, tableName: _request.tableName, rowsExported: 2, totalRows: 2, status: "Done" };
});
});
test("copy row JSON expands nested JSON strings", async () => {
const contextCell = ref({ rowId: 1, rowIndex: 0, col: 0 });
const jsonString = '{"endingBalance":{"beginningBalance":"0","endingBalance":"20000","endingDate":"2024-10-30"},"financeChargeInfo":null,"interestChargeInfo":null,"Line":[]}';
const row = {
id: 1,
data: ["67218700e884ae1f527640b6", jsonString, "draft"],
isNew: false,
isDeleted: false,
isDirtyCol: [false, false, false],
status: "",
};
const composable = useDataGridExport({
columns: computed(() => ["_id", "data", "status"]),
displayItems: computed(() => [row]),
sql: computed(() => undefined),
tableMeta: computed(() => undefined),
databaseType: computed(() => "mongodb"),
connectionId: computed(() => "conn-1"),
database: computed(() => "db"),
context: computed(() => "results"),
sourceColumns: computed(() => undefined),
columnTypes: computed(() => undefined),
whereInput: computed(() => undefined),
orderBy: computed(() => undefined),
exportBatchSize: computed(() => 1000),
hasCellSelection: computed(() => false),
selectedCells: computed(() => ({ columns: [], rows: [] })),
selectedRange: computed(() => null),
contextCell,
getRowItem: () => row,
selectedRowIds: ref(new Set<number>()),
hasRowSelection: computed(() => false),
});
await composable.copyRow();
assert.equal(clipboardMock.copyToClipboard.mock.calls.length, 1);
assert.deepEqual(JSON.parse(clipboardMock.copyToClipboard.mock.calls[0][0]), {
_id: "67218700e884ae1f527640b6",
data: {
endingBalance: {
beginningBalance: "0",
endingBalance: "20000",
endingDate: "2024-10-30",
},
financeChargeInfo: null,
interestChargeInfo: null,
Line: [],
},
status: "draft",
});
});
test("copy row JSON keeps nested JSON strings for non-MongoDB rows", async () => {
const contextCell = ref({ rowId: 1, rowIndex: 0, col: 0 });
const jsonString = '{"enabled":true}';
const row = {
id: 1,
data: [1, jsonString],
isNew: false,
isDeleted: false,
isDirtyCol: [false, false],
status: "",
};
const composable = useDataGridExport({
columns: computed(() => ["id", "payload"]),
displayItems: computed(() => [row]),
sql: computed(() => undefined),
tableMeta: computed(() => undefined),
databaseType: computed(() => "mysql"),
connectionId: computed(() => "conn-1"),
database: computed(() => "db"),
context: computed(() => "table"),
sourceColumns: computed(() => undefined),
columnTypes: computed(() => undefined),
whereInput: computed(() => undefined),
orderBy: computed(() => undefined),
exportBatchSize: computed(() => 1000),
hasCellSelection: computed(() => false),
selectedCells: computed(() => ({ columns: [], rows: [] })),
selectedRange: computed(() => null),
contextCell,
getRowItem: () => row,
selectedRowIds: ref(new Set<number>()),
hasRowSelection: computed(() => false),
});
await composable.copyRow();
assert.deepEqual(JSON.parse(clipboardMock.copyToClipboard.mock.calls[0][0]), {
id: 1,
payload: jsonString,
});
});
test("default data grid export file names use sanitized base names and compact local timestamps", () => {
vi.useFakeTimers();
try {
vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
assert.equal(defaultDataGridExportFileName("daily/report.sql", "export", "csv"), "daily_report_260602150405.csv");
assert.equal(defaultDataGridExportFileName("daily/report.sql", "export", "xlsx", { page: true }), "daily_report_page_260602150405.xlsx");
assert.equal(defaultDataGridExportFileName(" .sql ", "query-result", "csv"), "query-result_260602150405.csv");
} finally {
vi.useRealTimers();
}
});
test("full query result CSV export streams through the backend without loading all rows", async () => {
useSettingsStore().updateEditorSettings({ globalDateTimeExportFormat: "YYYY/M/D HH:mm:ss", csvQuoteMode: "necessary" });
const { composable, fullExportResult, queryResultExportRequest, exportProgressDialog, exportProgressState } = buildExportHarness();
await composable.exportCsv();
assert.equal(fullExportResult.mock.calls.length, 0);
assert.equal(queryResultExportRequest.mock.calls.length, 1);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 1);
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].dateTimeFormat, "YYYY/M/D HH:mm:ss");
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].csvQuoteMode, "necessary");
assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 0);
assert.equal(exportProgressDialog.value, true);
assert.equal(exportProgressState.value.status, "Done");
assert.equal(exportProgressState.value.filePath, apiMock.startQueryResultExport.mock.calls[0][0].filePath);
});
test("MongoDB full query result CSV export uses the full-result fallback", async () => {
const { composable, fullExportResult, queryResultExportRequest } = buildExportHarness({ databaseType: "mongodb", columns: ["_id", "name"] });
fullExportResult.mockResolvedValueOnce({
columns: ["_id", "name"],
rows: [["1", "Ada"]],
affected_rows: 1,
execution_time_ms: 1,
});
await composable.exportCsv();
assert.equal(queryResultExportRequest.mock.calls.length, 0);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
assert.equal(fullExportResult.mock.calls.length, 1);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][1], ["_id", "name"]);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][2], [["1", "Ada"]]);
});
test("streaming query result export translates streaming unsupported error before the toast", async () => {
const rawMessage = "Streaming export is unsupported for this query. Simplify it or use a supported driver.";
apiMock.startQueryResultExport.mockImplementationOnce(async (request, onProgress) => {
onProgress({ exportId: request.exportId, tableName: "", rowsExported: 0, totalRows: 0, status: "Error", errorMessage: rawMessage });
throw new Error(rawMessage);
});
const { composable, exportProgressState } = buildExportHarness();
await composable.exportXlsx();
assert.equal(exportProgressState.value.errorMessage, rawMessage);
assert.deepEqual(toastMock.mock.calls.at(-1), ["导出失败:当前查询暂不支持流式导出,请简化查询或使用受支持的驱动。", 5000]);
});
test("complete local query result XLSX export does not re-execute the query", async () => {
const completeLocalResult: QueryResult = {
columns: ["id", "name"],
column_types: ["int4", "text"],
rows: [
[1, "Ada"],
[2, "Lin"],
],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
const { composable, fullExportResult, queryResultExportRequest } = buildExportHarness({ completeLocalResult });
await composable.exportXlsx();
assert.equal(fullExportResult.mock.calls.length, 0);
assert.equal(queryResultExportRequest.mock.calls.length, 0);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0]?.slice(1, 6), ["Export", ["id", "name"], ["int4", "text"], undefined, completeLocalResult.rows]);
});
test("MySQL joined query SQL export keeps result aliases instead of source column names", async () => {
const download = installTextDownloadCapture();
const completeLocalResult: QueryResult = {
columns: ["order_no", "customer_name", "total_amount"],
column_types: ["int", "varchar", "decimal"],
rows: [[101, "Ada", "25.50"]],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
apiMock.buildExportSqlInsert.mockResolvedValueOnce("INSERT INTO `orders` (`order_no`, `customer_name`, `total_amount`) VALUES (101, 'Ada', 25.50);");
try {
const { composable } = buildExportHarness({
columns: completeLocalResult.columns,
rows: completeLocalResult.rows,
completeLocalResult,
databaseType: "mysql",
tableMeta: {
tableName: "orders",
primaryKeys: ["id"],
},
sourceColumns: ["id", undefined, "amount"],
});
await composable.exportSql();
assert.deepEqual(apiMock.buildExportSqlInsert.mock.calls[0][0].columns, ["order_no", "customer_name", "total_amount"]);
assert.deepEqual(apiMock.buildExportSqlInsert.mock.calls[0][0].rows, [[101, "Ada", "25.50"]]);
assert.match((await download.content()) ?? "", /`order_no`, `customer_name`, `total_amount`/);
} finally {
download.restore();
}
});
test("non-SQL query exports do not forward the INSERT mode", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/query-result.csv");
const { composable, queryResultExportRequest } = buildExportHarness();
await composable.exportCsv();
assert.equal("insertMode" in queryResultExportRequest.mock.calls[0][0], false);
assert.equal("insertMode" in apiMock.startQueryResultExport.mock.calls[0][0], false);
});
test("SQL export uses batch mode by default for query-result streaming", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/query-result.sql");
const { composable, queryResultExportRequest } = buildExportHarness();
await composable.exportSql();
assert.equal(sqlInsertModeMock.showSqlInsertModeDialog.mock.calls.length, 1);
assert.equal(queryResultExportRequest.mock.calls[0][0].insertMode, "batch");
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].insertMode, "batch");
});
test("SQL export forwards the selected single-row mode to query-result streaming", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/query-result.sql");
sqlInsertModeMock.showSqlInsertModeDialog.mockResolvedValueOnce("single");
const { composable, queryResultExportRequest } = buildExportHarness();
await composable.exportSql();
assert.equal(queryResultExportRequest.mock.calls[0][0].insertMode, "single");
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].insertMode, "single");
});
test("table data SQL export forwards the selected mode to the table backend", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/users.sql");
sqlInsertModeMock.showSqlInsertModeDialog.mockResolvedValueOnce("single");
const { composable } = buildTableDataExportHarness();
await composable.exportSql();
assert.equal(apiMock.startTableExport.mock.calls[0][0].format, "sql");
assert.equal(apiMock.startTableExport.mock.calls[0][0].insertMode, "single");
});
test("local SQL export maps the selected mode to the shared formatter", async () => {
const download = installTextDownloadCapture();
sqlInsertModeMock.showSqlInsertModeDialog.mockResolvedValueOnce("single");
apiMock.buildExportSqlInsert.mockResolvedValueOnce("INSERT INTO `users` (`id`, `name`) VALUES (1, 'Ada');");
try {
const completeLocalResult: QueryResult = {
columns: ["id", "name"],
column_types: ["int", "text"],
rows: [[1, "Ada"]],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
const { composable } = buildExportHarness({ completeLocalResult });
await composable.exportSql();
assert.equal(apiMock.buildExportSqlInsert.mock.calls[0][0].batchSize, 1);
} finally {
download.restore();
}
});
test.each([
["oracle", "all"],
["oracle", "page"],
["oceanbase-oracle", "all"],
["oceanbase-oracle", "page"],
] as const)("local %s %s SQL export preserves temporal precision and timezone", async (databaseType, scope) => {
const download = installTextDownloadCapture();
apiMock.buildExportSqlInsert.mockResolvedValueOnce("INSERT INTO fixture VALUES (1);");
const timestamp = "2026-10-13T12:34:56.123456789+08:00";
try {
const completeLocalResult: QueryResult = {
columns: ["id", "created_at"],
column_types: ["NUMBER", "TIMESTAMP WITH TIME ZONE"],
rows: [[1, timestamp]],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
const { composable } = buildExportHarness({
databaseType,
columns: completeLocalResult.columns,
columnTypes: completeLocalResult.column_types,
rows: completeLocalResult.rows,
completeLocalResult,
displayValue: () => "2026-10-13 12:34:56",
});
await (scope === "all" ? composable.exportSql() : composable.exportCurrentPageSql());
assert.deepEqual(apiMock.buildExportSqlInsert.mock.calls[0][0].rows, [[1, timestamp]]);
} finally {
download.restore();
}
});
test("local SQL export defaults to the shared batch formatter", async () => {
const download = installTextDownloadCapture();
apiMock.buildExportSqlInsert.mockResolvedValueOnce("INSERT INTO `users` (`id`, `name`) VALUES (1, 'Ada'), (2, 'Lin');");
try {
const completeLocalResult: QueryResult = {
columns: ["id", "name"],
column_types: ["int", "text"],
rows: [
[1, "Ada"],
[2, "Lin"],
],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
const { composable } = buildExportHarness({ completeLocalResult });
await composable.exportSql();
assert.equal(apiMock.buildExportSqlInsert.mock.calls[0][0].batchSize, undefined);
} finally {
download.restore();
}
});
test("background SQL export keeps full result column types when visible columns are reordered", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/query-result.sql");
const { composable, queryResultExportRequest } = buildExportHarness({
columns: ["payload", "created_at"],
columnTypes: ["jsonb", "timestamp"],
allColumnTypes: ["bytea", "jsonb", "timestamp"],
tableMeta: { tableName: "events", primaryKeys: ["id"] },
});
await composable.exportSql();
assert.deepEqual(queryResultExportRequest.mock.calls[0][0].exportColumnTypes, ["bytea", "jsonb", "timestamp"]);
assert.deepEqual(apiMock.startQueryResultExport.mock.calls[0][0].exportColumnTypes, ["bytea", "jsonb", "timestamp"]);
});
test("table data SQL export keeps source column names", async () => {
const download = installTextDownloadCapture();
apiMock.buildExportSqlInsert.mockResolvedValueOnce("INSERT INTO `users` (`id`, `name`) VALUES (1, 'Ada');");
try {
const { composable } = buildExportHarness({
columns: ["display_id", "display_name"],
rows: [[1, "Ada"]],
databaseType: "mysql",
context: "table-data",
tableMeta: {
tableName: "users",
primaryKeys: ["id"],
},
sourceColumns: ["id", "name"],
});
await composable.exportSql([1]);
assert.deepEqual(apiMock.buildExportSqlInsert.mock.calls[0][0].columns, ["id", "name"]);
assert.match((await download.content()) ?? "", /`id`, `name`/);
} finally {
download.restore();
}
});
function sqlExclusionOptions(primaryKeyMode: DataGridExtractorOptions["sql"]["primaryKeyMode"] = "exclude-generated"): DataGridExtractorOptions {
return {
...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS,
sql: { ...DEFAULT_DATA_GRID_EXTRACTOR_OPTIONS.sql, primaryKeyMode },
};
}
test("table data SQL export passes primary key exclusion to the backend", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/users.sql");
const { composable } = buildExportHarness({
context: "table-data",
tableMeta: {
tableName: "users",
primaryKeys: ["id"],
columns: [
{ name: "id", data_type: "integer", is_nullable: false, is_primary_key: true, extra: "auto_increment" },
{ name: "name", data_type: "text", is_nullable: true },
],
},
extractorOptions: sqlExclusionOptions(),
});
await composable.exportSql();
assert.equal(apiMock.startTableExport.mock.calls[0][0].primaryKeyMode, "exclude-generated");
assert.deepEqual(apiMock.startTableExport.mock.calls[0][0].primaryKeys, ["id"]);
});
test("query result SQL export passes primary key exclusion and keys to the backend", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/query-result.sql");
const { composable } = buildExportHarness({
context: "results",
tableMeta: {
tableName: "users",
primaryKeys: ["id"],
columns: [
{ name: "id", data_type: "integer", is_nullable: false, is_primary_key: true, extra: "auto_increment" },
{ name: "name", data_type: "text", is_nullable: true },
],
},
extractorOptions: sqlExclusionOptions(),
});
await composable.exportSql();
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].primaryKeyMode, "exclude-generated");
assert.deepEqual(apiMock.startQueryResultExport.mock.calls[0][0].primaryKeys, ["id"]);
});
test("table data SQL export keeps manually-assigned primary keys", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/users-manual-pk.sql");
const { composable } = buildExportHarness({
context: "table-data",
tableMeta: {
tableName: "users",
primaryKeys: ["user_code"],
columns: [{ name: "user_code", data_type: "varchar", is_nullable: false, is_primary_key: true }],
},
extractorOptions: sqlExclusionOptions(),
});
await composable.exportSql();
assert.equal(apiMock.startTableExport.mock.calls[0][0].primaryKeyMode, "exclude-generated");
assert.deepEqual(apiMock.startTableExport.mock.calls[0][0].primaryKeys, ["user_code"]);
});
test("table data SQL export passes all-primary-key mode including manual keys", async () => {
runtimeMock.isTauri = true;
dialogMock.save.mockResolvedValue("/tmp/users-all-keys.sql");
const { composable } = buildExportHarness({
context: "table-data",
tableMeta: {
tableName: "users",
primaryKeys: ["user_code"],
columns: [{ name: "user_code", data_type: "varchar", is_nullable: false, is_primary_key: true }],
},
extractorOptions: sqlExclusionOptions("exclude-all"),
});
await composable.exportSql();
assert.equal(apiMock.startTableExport.mock.calls[0][0].primaryKeyMode, "exclude-all");
assert.deepEqual(apiMock.startTableExport.mock.calls[0][0].primaryKeys, ["user_code"]);
});
test("local SQL export asks the backend to drop primary key columns", async () => {
const download = installTextDownloadCapture();
const completeLocalResult: QueryResult = {
columns: ["user_code", "name"],
column_types: ["varchar", "text"],
rows: [["A-1", "Ada"]],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
apiMock.buildExportSqlInsert.mockResolvedValueOnce('INSERT INTO "users" ("name") VALUES (\'Ada\');');
try {
const { composable } = buildExportHarness({
columns: completeLocalResult.columns,
rows: completeLocalResult.rows,
completeLocalResult,
tableMeta: {
tableName: "users",
primaryKeys: ["user_code"],
columns: [
{ name: "user_code", data_type: "varchar", is_nullable: false, is_primary_key: true },
{ name: "name", data_type: "text", is_nullable: true },
],
},
extractorOptions: sqlExclusionOptions("exclude-all"),
});
await composable.exportSql();
assert.deepEqual(apiMock.buildExportSqlInsert.mock.calls[0][0].excludeColumns, ["user_code"]);
assert.deepEqual(apiMock.buildExportSqlInsert.mock.calls[0][0].columns, ["user_code", "name"]);
} finally {
download.restore();
}
});
test("complete local query result export removes only internal hidden columns", async () => {
const completeLocalResult: QueryResult = {
columns: ["id", "name", "__DBX_PK_id"],
column_types: ["int4", "text", "int4"],
rows: [
[1, "Ada", 1],
[2, "Lin", 2],
],
hidden_column_indexes: [2],
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
const { composable } = buildExportHarness({ columns: ["id"], completeLocalResult });
await composable.exportXlsx();
assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0]?.slice(1, 6), [
"Export",
["id", "name"],
["int4", "text"],
undefined,
[
[1, "Ada"],
[2, "Lin"],
],
]);
});
test("complete local CSV, XLSX, and TXT exports honor the enabled row limit", async () => {
useSettingsStore().updateEditorSettings({ exportRowLimitEnabled: true, exportRowLimit: 100 });
const completeLocalResult: QueryResult = {
columns: ["id"],
column_types: ["int4"],
rows: Array.from({ length: 101 }, (_, index) => [index + 1]),
affected_rows: 0,
execution_time_ms: 1,
truncated: false,
has_more: false,
};
const { composable } = buildExportHarness({ completeLocalResult });
await composable.exportCsv();
assert.equal(apiMock.exportQueryResultCsv.mock.calls[0]?.[2].length, 100);
await composable.exportXlsx();
assert.equal(apiMock.exportQueryResultXlsx.mock.calls[0]?.[5].length, 100);
const download = installTextDownloadCapture();
try {
await composable.exportTxt();
const lines = (await download.content())?.split("\n");
assert.equal(lines?.length, 101);
assert.equal(lines?.at(-1), "100");
} finally {
download.restore();
}
});
test("full query result CSV export defaults to the saved SQL title", async () => {
vi.useFakeTimers();
try {
vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
const { composable, queryResultExportRequest } = buildExportHarness({ exportFileBaseName: "daily/report.sql" });
await composable.exportCsv();
assert.equal(queryResultExportRequest.mock.calls[0][0].filePath, "daily_report_260602150405.csv");
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].filePath, "daily_report_260602150405.csv");
} finally {
vi.useRealTimers();
}
});
test("selected query result CSV export defaults to the saved SQL title", async () => {
vi.useFakeTimers();
try {
vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
const { composable } = buildExportHarness({ exportFileBaseName: "daily/report.sql" });
await composable.exportCsv([1]);
assert.equal(apiMock.exportQueryResultCsv.mock.calls[0][0], "daily_report_260602150405.csv");
} finally {
vi.useRealTimers();
}
});
test("table data export keeps the table name as the default file base", async () => {
vi.useFakeTimers();
const restoreStorage = installMemoryStorage();
try {
vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
const { composable, exportProgressState } = buildTableDataExportHarness();
await composable.exportCsv();
assert.equal(apiMock.startTableExport.mock.calls[0][0].filePath, "users_260602150405.csv");
assert.equal(exportProgressState.value.filePath, "users_260602150405.csv");
} finally {
vi.useRealTimers();
restoreStorage();
}
});
test("query result CSV cancel handler passes export and execution ids", async () => {
const { composable, exportCancelHandler } = buildExportHarness();
let resolveExport!: () => void;
apiMock.startQueryResultExport.mockImplementationOnce(async (_request, onProgress) => {
await new Promise<void>((resolve) => {
resolveExport = () => {
onProgress({
exportId: _request.exportId,
tableName: "",
rowsExported: 1,
totalRows: 2,
status: "Cancelled",
errorMessage: "Export cancelled",
});
resolve();
};
});
return {
exportId: _request.exportId,
tableName: "",
rowsExported: 1,
totalRows: 2,
status: "Cancelled",
errorMessage: "Export cancelled",
};
});
const exportPromise = composable.exportCsv();
await vi.waitFor(() => assert.ok(exportCancelHandler.value));
await exportCancelHandler.value?.();
const request = apiMock.startQueryResultExport.mock.calls[0][0];
assert.deepEqual(apiMock.cancelQueryResultExport.mock.calls[0], [request.exportId, "exec-1"]);
resolveExport();
await exportPromise;
});
test("missing query result export request does not fall back to the in-memory path", async () => {
const { composable, fullExportResult, queryResultExportRequest } = buildExportHarness();
queryResultExportRequest.mockResolvedValueOnce(undefined);
await composable.exportCsv();
assert.equal(queryResultExportRequest.mock.calls.length, 1);
assert.equal(fullExportResult.mock.calls.length, 0);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 0);
});
test("selected query result CSV export keeps the existing in-memory path", async () => {
useSettingsStore().updateEditorSettings({ csvQuoteMode: "necessary" });
const { composable, queryResultExportRequest } = buildExportHarness();
await composable.exportCsv([1]);
assert.equal(queryResultExportRequest.mock.calls.length, 0);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 1);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][1], ["id", "name"]);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][2], [[1, "Ada"]]);
assert.equal(apiMock.exportQueryResultCsv.mock.calls[0][3], "necessary");
});
test("selected query result CSV export formats typed temporal columns without a formula wrapper", async () => {
useSettingsStore().updateEditorSettings({ globalDateTimeExportFormat: "YYYY/M/D HH:mm:ss" });
const rawDateTime = "2024-02-25 13:02:15";
const { composable } = buildExportHarness({
columns: ["created_at", "note"],
columnTypes: ["timestamp", "varchar"],
rows: [[rawDateTime, rawDateTime]],
});
await composable.exportCsv([1]);
// Temporal columns use the configured export format; plain columns are untouched.
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][2], [["2024/2/25 13:02:15", rawDateTime]]);
});
test("selected query result XLSX export uses the current source label as the sheet name", async () => {
const { composable, queryResultExportRequest } = buildExportHarness({ currentResultLabel: "aaa.apis", columnTypes: ["bigint(20)", "varchar(64)"] });
await composable.exportXlsx([1]);
assert.equal(queryResultExportRequest.mock.calls.length, 0);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls.length, 1);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls[0][1], "aaa.apis");
assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0][2], ["id", "name"]);
assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0][3], ["bigint(20)", "varchar(64)"]);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls[0][4], undefined);
assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0][5], [[1, "Ada"]]);
});
test("selected query result XLSX export forwards the numericColumnRightAlign setting to the backend", async () => {
const settingsStore = useSettingsStore();
settingsStore.updateEditorSettings({ numericColumnRightAlign: false });
const { composable } = buildExportHarness({ columnTypes: ["bigint(20)", "varchar(64)"] });
await composable.exportXlsx([1]);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls.length, 1);
// Argument 6 is `numericColumnRightAlign`, and must reflect the persisted
// setting rather than always defaulting to true.
assert.equal(apiMock.exportQueryResultXlsx.mock.calls[0][6], false);
settingsStore.updateEditorSettings({ numericColumnRightAlign: true });
await composable.exportXlsx([1]);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls[1][6], true);
});
test("selected query result XLSX export forwards the global export pattern so numFmt keeps milliseconds", async () => {
useSettingsStore().updateEditorSettings({ globalDateTimeExportFormat: "YYYY-MM-DD HH:mm:ss.SSS" });
const { composable } = buildExportHarness({
columns: ["id", "ts", "note"],
columnTypes: ["int", "datetime(3)", "varchar(32)"],
rows: [[1, "2026-07-25 13:02:15.456", "with-ms"]],
});
await composable.exportXlsx([1]);
// The rows already carry the formatted value, but without argument 8 the
// workbook falls back to a `yyyy-mm-dd hh:mm:ss` numFmt and hides the
// milliseconds it just wrote.
assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0][5], [[1, "2026-07-25 13:02:15.456", "with-ms"]]);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls[0][8], "YYYY-MM-DD HH:mm:ss.SSS");
});
test("selected query result XLSX export omits the export pattern when none is configured", async () => {
useSettingsStore().updateEditorSettings({ globalDateTimeExportFormat: "" });
const { composable } = buildExportHarness({ columnTypes: ["bigint(20)", "varchar(64)"] });
await composable.exportXlsx([1]);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls[0][8], undefined);
});
test("streaming query result XLSX export carries numericColumnRightAlign in the backend request", async () => {
const settingsStore = useSettingsStore();
settingsStore.updateEditorSettings({ numericColumnRightAlign: false });
const { composable, queryResultExportRequest } = buildExportHarness();
await composable.exportXlsxWithSql();
assert.equal(queryResultExportRequest.mock.calls.length, 1);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 1);
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].numericColumnRightAlign, false);
});
test("streaming XLSX with SQL marks the backend request as opt in", async () => {
const { composable, queryResultExportRequest } = buildExportHarness();
await composable.exportXlsxWithSql();
assert.equal(queryResultExportRequest.mock.calls[0][0].includeSqlSheet, true);
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].includeSqlSheet, true);
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].sql, "SELECT * FROM users");
assert.equal(apiMock.exportQueryResultsXlsx.mock.calls.length, 0);
});
test("streaming TXT export remains on the backend path without a SQL sheet", async () => {
const { composable, queryResultExportRequest } = buildExportHarness();
await composable.exportTxt();
assert.equal(queryResultExportRequest.mock.calls[0][0].format, "txt");
assert.equal(queryResultExportRequest.mock.calls[0][0].includeSqlSheet, false);
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].format, "txt");
assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].includeSqlSheet, false);
assert.equal(apiMock.exportQueryResultsXlsx.mock.calls.length, 0);
});
test("selected XLSX with SQL uses the effective result SQL in a second worksheet", async () => {
const { composable, queryResultExportRequest } = buildExportHarness({ currentResultLabel: "public.users" });
await composable.exportXlsxWithSql([1]);
assert.equal(queryResultExportRequest.mock.calls.length, 0);
assert.equal(apiMock.exportQueryResultXlsx.mock.calls.length, 0);
assert.equal(apiMock.exportQueryResultsXlsx.mock.calls.length, 1);
const worksheets = apiMock.exportQueryResultsXlsx.mock.calls[0][1];
assert.equal(worksheets[0].sheetName, "public.users");
assert.deepEqual(worksheets[0].rows, [[1, "Ada"]]);
assert.equal(worksheets[1].sheetName, "SQL");
assert.deepEqual(worksheets[1].rows, [["SELECT * FROM users ORDER BY id DESC"]]);
assert.equal(worksheets[1].autoFilter, false);
});
test("exportCurrentPageXlsxWithSql prioritizes pageSql over base query and disables autoFilter on SQL worksheet", async () => {
apiMock.exportQueryResultsXlsx.mockClear();
const { composable } = buildExportHarness({
currentResultLabel: "public.users",
sql: "SELECT * FROM users",
exportSql: "SELECT * FROM users ORDER BY id DESC",
pageSql: "SELECT * FROM users ORDER BY id DESC LIMIT 50 OFFSET 0",
});
await composable.exportCurrentPageXlsxWithSql();
assert.equal(apiMock.exportQueryResultsXlsx.mock.calls.length, 1);
const worksheets = apiMock.exportQueryResultsXlsx.mock.calls[0][1];
assert.equal(worksheets.length, 2);
assert.equal(worksheets[0].sheetName, "public.users");
assert.equal(worksheets[1].sheetName, "SQL");
assert.deepEqual(worksheets[1].rows, [["SELECT * FROM users ORDER BY id DESC LIMIT 50 OFFSET 0"]]);
assert.equal(worksheets[1].autoFilter, false);
});
test("exportCurrentPageXlsxWithSql falls back to exportSql when pageSql is unset", async () => {
apiMock.exportQueryResultsXlsx.mockClear();
const { composable } = buildExportHarness({
currentResultLabel: "public.users",
sql: "SELECT * FROM users",
exportSql: "SELECT * FROM users ORDER BY id DESC",
});
await composable.exportCurrentPageXlsxWithSql();
assert.equal(apiMock.exportQueryResultsXlsx.mock.calls.length, 1);
const worksheets = apiMock.exportQueryResultsXlsx.mock.calls[0][1];
assert.equal(worksheets.length, 2);
assert.equal(worksheets[1].sheetName, "SQL");
assert.deepEqual(worksheets[1].rows, [["SELECT * FROM users ORDER BY id DESC"]]);
assert.equal(worksheets[1].autoFilter, false);
});
test("all-results XLSX with SQL maps each result set to its source statement", async () => {
const allExportResults = [
{ sheetName: "Result 1", result: { columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, sourceStatement: "SELECT 1" }, sql: "SELECT 1" },
{ sheetName: "Result 2", result: { columns: ["id"], rows: [[2]], affected_rows: 0, execution_time_ms: 1, sourceStatement: "SELECT 2" }, sql: "SELECT 2 ORDER BY 1" },
];
const { composable } = buildExportHarness({ allExportResults });
await composable.exportAllResultsXlsxWithSql();
const worksheets = apiMock.exportQueryResultsXlsx.mock.calls[0][1];
assert.equal(worksheets.length, 3);
assert.equal(worksheets[2].sheetName, "SQL");
assert.deepEqual(worksheets[2].rows, [
["Result 1", "SELECT 1"],
["Result 2", "SELECT 2 ORDER BY 1"],
]);
});
test("cancelled query result CSV export clears the cancel handler without using the in-memory path", async () => {
const { composable, fullExportResult, exportProgressState, exportCancelHandler } = buildExportHarness();
apiMock.startQueryResultExport.mockImplementationOnce(async (_request, onProgress) => {
onProgress({
exportId: _request.exportId,
tableName: "",
rowsExported: 1,
totalRows: 2,
status: "Cancelled",
errorMessage: "Export cancelled",
});
return {
exportId: _request.exportId,
tableName: "",
rowsExported: 1,
totalRows: 2,
status: "Cancelled",
errorMessage: "Export cancelled",
};
});
await composable.exportCsv();
assert.equal(fullExportResult.mock.calls.length, 0);
assert.equal(apiMock.startQueryResultExport.mock.calls.length, 1);
assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 0);
assert.equal(exportProgressState.value.status, "Cancelled");
assert.equal(exportProgressState.value.errorMessage, "Export cancelled");
assert.equal(exportCancelHandler.value, null);
});
test("table data export leaves row limit unset by default", async () => {
const restoreStorage = installMemoryStorage();
try {
const { composable } = buildTableDataExportHarness();
await composable.exportCsv();
assert.equal(apiMock.startTableExport.mock.calls.length, 1);
assert.equal(apiMock.startTableExport.mock.calls[0][0].rowLimit, null);
assert.equal(apiMock.startTableExport.mock.calls[0][0].csvQuoteMode, "all");
} finally {
restoreStorage();
}
});
test("table data export passes the global date time export format", async () => {
const restoreStorage = installMemoryStorage();
try {
useSettingsStore().updateEditorSettings({ globalDateTimeExportFormat: "YYYY/MM/DD HH:mm:ss" });
const { composable } = buildTableDataExportHarness();
await composable.exportCsv();
assert.equal(apiMock.startTableExport.mock.calls[0][0].dateTimeFormat, "YYYY/MM/DD HH:mm:ss");
} finally {
restoreStorage();
}
});
test("table data export requests row count for determinate progress", async () => {
const restoreStorage = installMemoryStorage();
try {
const { composable, exportProgressState } = buildTableDataExportHarness();
await composable.exportCsv();
assert.equal(apiMock.startTableExport.mock.calls.length, 1);
assert.equal(apiMock.startTableExport.mock.calls[0][0].skipCount, false);
assert.equal(exportProgressState.value.totalRows, 2);
} finally {
restoreStorage();
}
});
test("table data export passes row limit when enabled", async () => {
const restoreStorage = installMemoryStorage();
try {
const settingsStore = useSettingsStore();
settingsStore.updateEditorSettings({ exportRowLimitEnabled: true, exportRowLimit: 12_345 });
const { composable } = buildTableDataExportHarness();
await composable.exportCsv();
assert.equal(apiMock.startTableExport.mock.calls.length, 1);
assert.equal(apiMock.startTableExport.mock.calls[0][0].rowLimit, 12_345);
} finally {
restoreStorage();
}
});
test("selected query result CSV export formats column values when column formatter is active", async () => {
const restoreStorage = installMemoryStorage();
try {
const { composable } = buildExportHarness({
columns: ["id", "amount", "name"],
columnTypes: ["integer", "numeric", "text"],
rows: [
[1, 100, "Ada"],
[2, null, "Lin"],
],
hasColumnFormatter: (idx) => idx === 1,
displayValue: (val, idx) => (idx === 1 ? `$${val}.00` : String(val)),
});
await composable.exportCsv([1, 2]);
assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 1);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][1], ["id", "amount", "name"]);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][2], [
[1, "$100.00", "Ada"],
[2, null, "Lin"],
]);
} finally {
restoreStorage();
}
});
test("selected query result CSV export preserves raw values when applyColumnFormattersOnExport is false", async () => {
const restoreStorage = installMemoryStorage();
try {
useSettingsStore().updateEditorSettings({ applyColumnFormattersOnExport: false });
const { composable } = buildExportHarness({
columns: ["id", "amount"],
columnTypes: ["integer", "numeric"],
rows: [[1, 100]],
hasColumnFormatter: (idx) => idx === 1,
displayValue: (val, idx) => (idx === 1 ? `$${val}.00` : String(val)),
});
await composable.exportCsv([1]);
assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 1);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][2], [[1, 100]]);
} finally {
restoreStorage();
}
});
test("table data CSV export bypasses backend streaming when column formatters are active", async () => {
const restoreStorage = installMemoryStorage();
try {
const fullExportResult = vi.fn(async () => ({
columns: ["id", "name"],
rows: [
[1, "Alice"],
[2, "Bob"],
],
column_types: ["integer", "text"],
}));
const { composable } = buildTableDataExportHarness({
hasColumnFormatter: (idx) => idx === 1,
displayValue: (val, idx) => (idx === 1 ? String(val).toUpperCase() : String(val)),
fullExportResult,
});
await composable.exportCsv();
assert.equal(apiMock.startTableExport.mock.calls.length, 0);
assert.equal(fullExportResult.mock.calls.length, 1);
assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 1);
assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][2], [
[1, "ALICE"],
[2, "BOB"],
]);
} finally {
restoreStorage();
}
});
test("table data SQL export does not bypass backend streaming even when column formatters are active", async () => {
const restoreStorage = installMemoryStorage();
try {
const { composable } = buildTableDataExportHarness({
hasColumnFormatter: (idx) => idx === 1,
displayValue: (val, idx) => (idx === 1 ? String(val).toUpperCase() : String(val)),
});
await composable.exportSql();
assert.equal(apiMock.startTableExport.mock.calls.length, 1);
} finally {
restoreStorage();
}
});
test("copyCell applies column formatter when active and preserves raw values when disabled", async () => {
const restoreStorage = installMemoryStorage();
try {
const { composable, contextCell } = buildExportHarness({
columns: ["id", "price"],
rows: [[1, 42]],
hasColumnFormatter: (idx) => idx === 1,
displayValue: (val, idx) => (idx === 1 ? `$${val}` : String(val)),
});
contextCell.value = { rowId: 1, rowIndex: 0, col: 1 };
await composable.copyCell();
assert.equal(clipboardMock.copyToClipboard.mock.calls.length, 1);
assert.equal(clipboardMock.copyToClipboard.mock.calls[0][0], "$42");
clipboardMock.copyToClipboard.mockClear();
useSettingsStore().updateEditorSettings({ applyColumnFormattersOnExport: false });
await composable.copyCell();
assert.equal(clipboardMock.copyToClipboard.mock.calls.length, 1);
assert.equal(clipboardMock.copyToClipboard.mock.calls[0][0], "42");
} finally {
restoreStorage();
}
});